public void Create_With_Frozen_Udt()
{
string createQuery = null;
var serializer = new SerializerManager(ProtocolVersion.MaxSupported);
var sessionMock = GetSessionMock(serializer);
sessionMock
.Setup(s => s.Execute(It.IsAny <string>()))
.Returns(() => new RowSet())
.Callback <string>(q => createQuery = q);
var definition = new Map <UdtAndTuplePoco>()
.PartitionKey(c => c.Id1)
.Column(c => c.Id1, cm => cm.WithName("id"))
.Column(c => c.Udt1, cm => cm.WithName("my_udt").WithDbType <Song>().AsFrozen())
.ExplicitColumns()
.TableName("tbl1");
var udtInfo = new UdtColumnInfo("ks1.song");
udtInfo.Fields.Add(new ColumnDesc {
Name = "title", TypeCode = ColumnTypeCode.Ascii
});
udtInfo.Fields.Add(new ColumnDesc {
Name = "releasedate", TypeCode = ColumnTypeCode.Timestamp
});
var udtMap = UdtMap.For <Song>().SetIgnoreCase(false);
udtMap.SetSerializer(serializer.GetCurrentSerializer());
udtMap.Build(udtInfo);
serializer.SetUdtMap("song", udtMap);
var table = GetTable <UdtAndTuplePoco>(sessionMock.Object, definition);
table.Create();
Assert.AreEqual("CREATE TABLE tbl1 (id uuid, my_udt frozen<\"ks1\".\"song\">, PRIMARY KEY (id))", createQuery);
}
public async Task MappingSingleExplicitAsync_AsParameter()
{
var localSession = GetNewSession(KeyspaceName);
await localSession.UserDefinedTypes.DefineAsync(
UdtMap.For <Phone>("phone")
.Map(v => v.Alias, "alias")
.Map(v => v.CountryCode, "country_code")
.Map(v => v.Number, "number")
);
var phone = new Phone
{
Alias = "home phone",
Number = "85 988888888",
CountryCode = 55
};
localSession.Execute(new SimpleStatement("INSERT INTO users (id, main_phone) values (1, ?)", phone));
var rs = localSession.Execute("SELECT * FROM users WHERE id = 1");
var row = rs.First();
var value = row.GetValue <Phone>("main_phone");
Assert.NotNull(value);
Assert.AreEqual(phone.Alias, value.Alias);
Assert.AreEqual(phone.Number, value.Number);
Assert.AreEqual(phone.CountryCode, value.CountryCode);
}
public void MappingSingleExplicitTest()
{
foreach (var protocolVersion in UdtProtocolVersionSupported)
{
//Use all possible protocol versions
Cluster.MaxProtocolVersion = protocolVersion;
//Use a local cluster
var localCluster = Cluster.Builder().AddContactPoint(IpPrefix + "1").Build();
var localSession = localCluster.Connect("tester");
localSession.UserDefinedTypes.Define(
UdtMap.For <Phone>("phone")
.Map(v => v.Alias, "alias")
.Map(v => v.CountryCode, "country_code")
.Map(v => v.Number, "number")
);
localSession.Execute("INSERT INTO users (id, main_phone) values (1, {alias: 'home phone', number: '123', country_code: 34})");
var rs = localSession.Execute("SELECT * FROM users WHERE id = 1");
var row = rs.First();
var value = row.GetValue <Phone>("main_phone");
Assert.NotNull(value);
Assert.AreEqual("home phone", value.Alias);
Assert.AreEqual("123", value.Number);
Assert.AreEqual(34, value.CountryCode);
localCluster.Dispose();
}
}
public static void Install(IServiceCollection serviceCollection, String contactPoint, String keyspace)
{
serviceCollection.AddSingleton <Mappings, CassandraMappings>();
serviceCollection.AddSingleton <ICluster>(provider => Cluster.Builder().AddContactPoint((String)contactPoint).Build());
//serviceCollection.AddSingleton<IUnitOfWork, CassandraUnitOfWork>();
serviceCollection.AddSingleton <IUnitOfWork>(provider =>
{
var unitOfWork = new CassandraUnitOfWork(provider.GetRequiredService <ICluster>(), provider.GetRequiredService <Mappings>(), keyspace);
// Map UDTs
var session = unitOfWork.Session;
session.UserDefinedTypes.Define(
UdtMap.For <CaptureEntity>(),
UdtMap.For <L7PduEntity>(),
UdtMap.For <IPEndPointEntity>(),
UdtMap.For <L7ConversationEntity>()
);
return(unitOfWork);
});
serviceCollection.AddSingleton <IRepositoryWriterAsync <CaptureEntity>, UnitOfWork.CassandraRepository.BaseRepository <CaptureEntity> >();
serviceCollection.AddSingleton <IRepositoryWriterAsync <L7ConversationEntity>, UnitOfWork.CassandraRepository.BaseRepository <L7ConversationEntity> >();
}
public void Should_Allow_DataRange_In_Udt_And_Tuple()
{
const string insertQuery = "INSERT INTO tbl_udt_tuple (k, u, uf, t, tf) VALUES (?,?,?,?,?)";
const string selectQuery = "SELECT * FROM tbl_udt_tuple WHERE k = ?";
var id = Guid.NewGuid();
var dtExpected = DateRange.Parse("[2000-01-01T10:15:30.003Z TO 2020-01-01T10:15:30.001Z]");
Session.UserDefinedTypes.Define(
UdtMap.For <UdtDataRange>("test_udt")
.Map(v => v.Id, "i")
.Map(v => v.DateRange, "range")
);
var udtRangeValue = new UdtDataRange
{
Id = 1,
DateRange = dtExpected
};
var tuple1 = new Tuple <DateRange, int>(dtExpected, 30);
var tuple2 = new Tuple <DateRange, int>(dtExpected, 40);
Session.Execute(new SimpleStatement(insertQuery, id, udtRangeValue, udtRangeValue, tuple1, tuple2));
var rs = Session.Execute(new SimpleStatement(selectQuery, id));
var row = rs.First();
Assert.AreEqual(udtRangeValue, row.GetValue <UdtDataRange>("u"));
Assert.AreEqual(udtRangeValue, row.GetValue <UdtDataRange>("uf"));
Assert.AreEqual(tuple1, row.GetValue <Tuple <DateRange, int> >("t"));
Assert.AreEqual(tuple2, row.GetValue <Tuple <DateRange, int> >("tf"));
}
public void MappingSingleExplicitNullsTest()
{
var localSession = GetNewSession(KeyspaceName);
localSession.UserDefinedTypes.Define(
UdtMap.For <Phone>("phone")
.Map(v => v.Alias, "alias")
.Map(v => v.CountryCode, "country_code")
.Map(v => v.Number, "number")
);
//Some fields are null
localSession.Execute("INSERT INTO users (id, main_phone) values (1, {alias: 'empty phone'})");
var row = localSession.Execute("SELECT * FROM users WHERE id = 1").First();
var value = row.GetValue <Phone>("main_phone");
Assert.NotNull(value);
Assert.AreEqual("empty phone", value.Alias);
//Default
Assert.IsNull(value.Number);
//Default
Assert.AreEqual(0, value.CountryCode);
//column value is null
localSession.Execute("INSERT INTO users (id, main_phone) values (2, null)");
row = localSession.Execute("SELECT * FROM users WHERE id = 2").First();
Assert.IsNull(row.GetValue <Phone>("main_phone"));
//first values are null
localSession.Execute("INSERT INTO users (id, main_phone) values (3, {country_code: 34})");
row = localSession.Execute("SELECT * FROM users WHERE id = 3").First();
Assert.IsNotNull(row.GetValue <Phone>("main_phone"));
Assert.AreEqual(34, row.GetValue <Phone>("main_phone").CountryCode);
Assert.IsNull(row.GetValue <Phone>("main_phone").Alias);
Assert.IsNull(row.GetValue <Phone>("main_phone").Number);
}
public void MappingDifferentKeyspaceWithoutSpecifyingIt()
{
const string cqlType1 = "CREATE TYPE phone2 (alias2 text, number2 text, country_code2 int, verified_at timestamp, phone_type text)";
const string cqlTable1 = "CREATE TABLE users2 (id int PRIMARY KEY, main_phone frozen<phone2>)";
var cluster = GetNewTemporaryCluster();
var newKeyspace = TestUtils.GetUniqueKeyspaceName().ToLowerInvariant();
var session = cluster.Connect();
session.CreateKeyspaceIfNotExists(newKeyspace);
session.ChangeKeyspace(newKeyspace);
session.Execute(cqlType1);
session.Execute(cqlTable1);
Assert.ThrowsAsync <InvalidTypeException>(() => session.UserDefinedTypes.DefineAsync(
UdtMap.For <Phone>("phone")
.Map(v => v.Alias, "alias")
.Map(v => v.CountryCode, "country_code")
.Map(v => v.Number, "number"),
UdtMap.For <Phone2>("phone2")
.Map(v => v.Alias, "alias2")
.Map(v => v.CountryCode, "country_code2")
.Map(v => v.Number, "number2")
));
}
public static void Install(IServiceCollection serviceCollection, String keyspace, params String[] contactPoints)
{
serviceCollection.AddSingleton <Mappings, CassandraMappings>();
serviceCollection.AddSingleton <ICluster>(provider => Cluster.Builder().AddContactPoints(contactPoints).Build());
serviceCollection.AddSingleton <IUnitOfWork>(provider =>
{
var unitOfWork = new CassandraUnitOfWork(provider.GetRequiredService <ICluster>(), provider.GetRequiredService <Mappings>(),
keyspace);
// Map UDTs (just UDTs, not entities with their own tables)
var session = unitOfWork.Session;
session.UserDefinedTypes.Define(UdtMap.For <L7PduEntity>(), UdtMap.For <IPEndPointEntity>());
return(unitOfWork);
});
serviceCollection.AddSingleton <IRepository <CaptureEntity>, BaseRepository <CaptureEntity> >();
serviceCollection.AddSingleton <IRepository <L7ConversationEntity>, BaseRepository <L7ConversationEntity> >();
serviceCollection.AddSingleton <IRepositoryWriterAsync <CaptureEntity> >(x => x.GetService <IRepository <CaptureEntity> >());
serviceCollection.AddSingleton <IRepositoryReaderAsync <CaptureEntity> >(x => x.GetService <IRepository <CaptureEntity> >());
serviceCollection.AddSingleton <IRepositoryWriterAsync <L7ConversationEntity> >(
x => x.GetService <IRepository <L7ConversationEntity> >());
serviceCollection.AddSingleton <IRepositoryReaderAsync <L7ConversationEntity> >(
x => x.GetService <IRepository <L7ConversationEntity> >());
}
public void Create_With_Frozen_Collection_Key()
{
string createQuery = null;
var sessionMock = new Mock <ISession>();
sessionMock
.Setup(s => s.Execute(It.IsAny <string>()))
.Returns(() => new RowSet())
.Callback <string>(q => createQuery = q);
var definition = new Map <UdtAndTuplePoco>()
.PartitionKey(c => c.Id1)
.Column(c => c.Id1, cm => cm.WithName("id"))
.Column(c => c.UdtSet1, cm => cm.WithName("my_set").WithDbType <SortedSet <Song> >().WithFrozenKey())
.Column(c => c.TupleMapKey1, cm => cm.WithName("my_map").WithFrozenKey())
.ExplicitColumns()
.TableName("tbl1");
var udtInfo = new UdtColumnInfo("song");
udtInfo.Fields.Add(new ColumnDesc {
Name = "title", TypeCode = ColumnTypeCode.Ascii
});
udtInfo.Fields.Add(new ColumnDesc {
Name = "releasedate", TypeCode = ColumnTypeCode.Timestamp
});
var udtMap = UdtMap.For <Song>();
udtMap.Build(udtInfo);
TypeCodec.SetUdtMap("song", udtMap);
var table = GetTable <UdtAndTuplePoco>(sessionMock.Object, definition);
table.Create();
Assert.AreEqual("CREATE TABLE tbl1 (id uuid, my_set set<frozen<song>>, my_map map<frozen<tuple<double, double>>, text>, PRIMARY KEY (id))", createQuery);
}
public static void Main()
{
var cluster = Cluster.Builder().AddContactPoint("127.0.0.1").Build();
var session = cluster.Connect();
session.CreateKeyspaceIfNotExists("testks");
session.ChangeKeyspace("testks");
session.Execute($"CREATE TYPE IF NOT EXISTS testks.{nameof(LogParamsCUDT)} (Key text, ValueString text);");
session.UserDefinedTypes.Define(UdtMap.For<LogParamsCUDT>($"{nameof(LogParamsCUDT)}", "testks"));
var table = new Table<Log>(session);
table.CreateIfNotExists();
table.Insert(new Log
{
LoggingLevel = 1,
UserId = Guid.NewGuid(),
TimeZone = "123",
Text = "123",
LogParams = new List<LogParamsCUDT>
{
new LogParamsCUDT
{
Key = "123",
ValueString = "321"
}
}
}).Execute();
var result = table.First(l => l.Text == "123").Execute();
Console.WriteLine(JsonConvert.SerializeObject(result));
Console.ReadLine();
table.Where(l => l.Text == "123").Delete().Execute();
}
internal object ToObject(IGraphTypeSerializer serializer, UdtMap map, IEnumerable <JToken> valuesArr)
{
var obj = Activator.CreateInstance(map.NetType);
var i = 0;
foreach (var value in valuesArr)
{
if (i >= map.Definition.Fields.Count)
{
break;
}
var field = map.Definition.Fields[i];
i++;
var prop = map.GetPropertyForUdtField(field.Name);
if (prop == null)
{
continue;
}
var convertedValue = serializer.FromDb(value, prop.PropertyType, false);
prop.SetValue(obj, convertedValue, null);
}
return(obj);
}
public void MappingCaseSensitiveTest()
{
var localSession = GetNewSession(KeyspaceName);
//Cassandra identifiers are lowercased by default
localSession.UserDefinedTypes.Define(
UdtMap.For <Phone>("phone")
.SetIgnoreCase(false)
.Map(v => v.Alias, "alias")
.Map(v => v.CountryCode, "country_code")
.Map(v => v.Number, "number")
);
localSession.Execute("INSERT INTO users (id, main_phone) values (101, {alias: 'home phone', number: '123', country_code: 34})");
var rs = localSession.Execute("SELECT * FROM users WHERE id = 101");
var row = rs.First();
var value = row.GetValue <Phone>("main_phone");
Assert.NotNull(value);
Assert.AreEqual("home phone", value.Alias);
Assert.AreEqual("123", value.Number);
Assert.AreEqual(34, value.CountryCode);
Assert.Throws <InvalidTypeException>(() => localSession.UserDefinedTypes.Define(
//The name should be forced to be case sensitive
UdtMap.For <Phone>("PhoNe")
.SetIgnoreCase(false)));
Assert.Throws <InvalidTypeException>(() => localSession.UserDefinedTypes.Define(
UdtMap.For <Phone>("phone")
.SetIgnoreCase(false)
//the field is called 'alias' it should fail
.Map(v => v.Alias, "Alias")
));
}
public void Should_Allow_Duration_In_Udt_And_Tuple()
{
const string insertQuery = "INSERT INTO tbl_duration_udt_tuple (k, u, uf, t, tf) VALUES (?,?,?,?,?)";
const string selectQuery = "SELECT * FROM tbl_duration_udt_tuple WHERE k = ?";
foreach (var value in Values)
{
var id = Guid.NewGuid();
var durationExpected = Duration.Parse(value);
Session.UserDefinedTypes.Define(
UdtMap.For <UdtDuration>("test_duration_udt")
.Map(v => v.Id, "i")
.Map(v => v.C1, "c1")
);
var udtRangeValue = new UdtDuration
{
Id = 1,
C1 = durationExpected
};
var tuple1 = new Tuple <Duration, int>(durationExpected, 30);
Session.Execute(new SimpleStatement(insertQuery, id, udtRangeValue, udtRangeValue, tuple1, tuple1));
var rs = Session.Execute(new SimpleStatement(selectQuery, id));
var row = rs.First();
Assert.AreEqual(udtRangeValue, row.GetValue <UdtDuration>("u"));
Assert.AreEqual(udtRangeValue, row.GetValue <UdtDuration>("uf"));
Assert.AreEqual(tuple1, row.GetValue <Tuple <Duration, int> >("t"));
Assert.AreEqual(tuple1, row.GetValue <Tuple <Duration, int> >("tf"));
}
}
public void MappingSingleExplicitTest()
{
var localSession = GetNewSession(KeyspaceName);
localSession.UserDefinedTypes.Define(
UdtMap.For <Phone>("phone")
.Map(v => v.Alias, "alias")
.Map(v => v.CountryCode, "country_code")
.Map(v => v.Number, "number")
.Map(v => v.VerifiedAt, "verified_at")
.Map(v => v.PhoneType, "phone_type")
);
var date = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(100000);
localSession.Execute($"INSERT INTO users (id, main_phone) values (1, {{alias: 'home phone', number: '123', country_code: 34, verified_at: '100000', phone_type: 'Home'}})");
var rs = localSession.Execute("SELECT * FROM users WHERE id = 1");
var row = rs.First();
var value = row.GetValue <Phone>("main_phone");
Assert.NotNull(value);
Assert.AreEqual("home phone", value.Alias);
Assert.AreEqual("123", value.Number);
Assert.AreEqual(34, value.CountryCode);
Assert.AreEqual(date, value.VerifiedAt);
Assert.AreEqual(PhoneType.Home, value.PhoneType);
}
private List <Row> selectPointDetails(int dataSetID, PointBase basicPoint)
{
CassandraQueryBuilder queryBuilder = new CassandraQueryBuilder()
{
QueryType = CassandraQueryBuilder.QueryTypes.Select
};
//update: do not use latitude and longitude to search for points details
queryBuilder.TableName = "points_by_dataset";
queryBuilder.ClausesList.Add(new BuilderTuple("dataSetID", "dataset_id", CassandraQueryBuilder.Clauses.Equals));
queryBuilder.ClausesList.Add(new BuilderTuple("number", "number", CassandraQueryBuilder.Clauses.Equals));
executionInstance.UserDefinedTypeMappings.Define(UdtMap.For <PointDisplacementType>("points_displacements"));
var preparedStatement = executionInstance.GetPreparedStatement("points_by_dataset", queryBuilder);
var result = executionInstance.ExecuteQuery(new
{
dataSetID,
number = basicPoint.Number
}, preparedStatement).Result;
return(result);
}
static void Main(string[] args)
{
var builder = new Builder()
.AddContactPoints("localhost");
var cluster = builder.Build();
var session = cluster.Connect("cassander");
session.UserDefinedTypes.Define(
new[]
{
UdtMap.For <AuthorTitle>()
.Map(x => x.Author, "author")
.Map(x => x.Title, "title")
}
);
var statement = new SimpleStatement("SELECT * FROM books");
var books = session.Query <Books>(statement);
foreach (var book in books)
{
Console.WriteLine($"{book.id} {book.stock} {book.creation_date} {book.name} {book.Authortitle?.Title}");
}
}
public void Should_ThrowException_When_UdtWithCollectionsWithNullValues()
{
var localSession = GetNewTemporarySession(KeyspaceName);
localSession.UserDefinedTypes.Define(UdtMap.For <UdtWithCollections>("udt_collections"));
var udtList = new List <UdtWithCollections>
{
// collections with null elements
new UdtWithCollections
{
Id = 1111,
NullableId = 4444,
NullableIntEnumerable = new int?[] { 6, null },
NullableIntList = new List <int?> {
7, null
}
},
};
var insert = new SimpleStatement("INSERT INTO table_udt_collections (id, udt, udt_list, nullable_id) values (?, ?, ?, ?)", 1111, null, udtList, 1000);
Assert.Throws <InvalidCastException>(() => localSession.Execute(insert));
insert = new SimpleStatement("INSERT INTO table_udt_collections (id, udt, udt_list) values (?, ?, ?)", 2222, udtList[0], null);
Assert.Throws <InvalidCastException>(() => localSession.Execute(insert));
insert = new SimpleStatement("INSERT INTO table_udt_collections (id, udt, udt_list) values (?, ?, ?)", 3333, null, new List <UdtWithCollections> {
null
});
Assert.Throws <ArgumentNullException>(() => localSession.Execute(insert));
}
public void Create_With_Frozen_Collection_Value()
{
string createQuery = null;
var serializer = new Serializer(ProtocolVersion.MaxSupported);
var sessionMock = GetSessionMock(serializer);
sessionMock
.Setup(s => s.Execute(It.IsAny <string>()))
.Returns(() => new RowSet())
.Callback <string>(q => createQuery = q);
var definition = new Map <UdtAndTuplePoco>()
.PartitionKey(c => c.Id1)
.Column(c => c.Id1, cm => cm.WithName("id"))
.Column(c => c.UdtList1, cm => cm.WithName("my_list").WithFrozenValue())
.Column(c => c.TupleMapValue1, cm => cm.WithName("my_map").WithFrozenValue())
.ExplicitColumns()
.TableName("tbl1");
var udtInfo = new UdtColumnInfo("song");
udtInfo.Fields.Add(new ColumnDesc {
Name = "title", TypeCode = ColumnTypeCode.Ascii
});
udtInfo.Fields.Add(new ColumnDesc {
Name = "releasedate", TypeCode = ColumnTypeCode.Timestamp
});
var udtMap = UdtMap.For <Song>();
udtMap.SetSerializer(serializer);
udtMap.Build(udtInfo);
serializer.SetUdtMap("song", udtMap);
var table = GetTable <UdtAndTuplePoco>(sessionMock.Object, definition);
table.Create();
Assert.AreEqual("CREATE TABLE tbl1 (id uuid, my_list list<frozen<\"song\">>, my_map map<text, frozen<tuple<double, double>>>, PRIMARY KEY (id))", createQuery);
}
public async Task RunWorkerAsync()
{
var cluster = Cluster.Builder()
.AddContactPoints(_config.Hosts)
.Build();
// Connect to the nodes using a keyspace
_session = await cluster.ConnectAsync("siteresources").ConfigureAwait(false);
_logger.Info("Connect cassandra");
_logger.Warn("Warning");
await _session.UserDefinedTypes.DefineAsync(
UdtMap.For <RstType>(udtName: "rst", keyspace: "siteresources")
);
var pcs_insert_statement = await _session.PrepareAsync(cql_pcs_insert_query).ConfigureAwait(false);
DateTime nextExecuteTime = DateTime.Now.Add(_config.WaitForBatch);
List <Task> insertTasks = new List <Task>();
while (true)
{
if (Token.IsCancellationRequested)
{
break;
}
Token.ThrowIfCancellationRequested();
JObject obj = await _queue.DequeueAsync(Token);
if (obj.ContainsKey(COMMON_KEYS.GROUPID_KEY) == false)
{
continue;
}
int group_id = obj[COMMON_KEYS.GROUPID_KEY].Value <int>();
if (group_id == 1) // PCS
{
insertTasks.Add(ExecuteInsertPcs(obj, pcs_insert_statement, _session));
}
if (insertTasks.Count >= _config.BatchCount || DateTime.Now >= nextExecuteTime)
{
await Task.WhenAll(insertTasks).ConfigureAwait(false);
_logger.Info($"Insert rows({insertTasks.Count}) data");
insertTasks.Clear();
nextExecuteTime = DateTime.Now.Add(_config.WaitForBatch);
}
await Task.Delay(10);
}
await cluster.ShutdownAsync().ConfigureAwait(false);
if (RunWorkerCompleted != null)
{
RunWorkerCompleted(this, new RunWorkerCompletedEventArgs(null, null, Token.IsCancellationRequested));
}
}
public void MappingNotExistingFieldsTest()
{
var localSession = GetNewSession(KeyspaceName);
Assert.Throws <InvalidTypeException>(() => localSession.UserDefinedTypes.Define(
//there is no field named like this
UdtMap.For <Phone>("phone").Map(v => v.Number, "Alias_X_WTF")
));
}
/// <inheritdoc />
public dynamic Objectify(
JToken graphsonObject, Type type, IGraphTypeSerializer serializer, IGenericSerializer genericSerializer)
{
var keyspace = serializer.FromDb <string>(graphsonObject["keyspace"]);
var name = serializer.FromDb <string>(graphsonObject["name"]);
var values = (JArray)graphsonObject["value"];
var targetTypeIsDictionary = false;
Type elementType = null;
if (type.GetTypeInfo().IsGenericType &&
(type.GetGenericTypeDefinition() == typeof(IReadOnlyDictionary <,>) ||
type.GetGenericTypeDefinition() == typeof(Dictionary <,>) ||
type.GetGenericTypeDefinition() == typeof(IDictionary <,>)))
{
targetTypeIsDictionary = true;
var genericArgs = type.GetTypeInfo().GetGenericArguments();
if (genericArgs[0] != typeof(string))
{
throw new InvalidOperationException(
"Deserializing UDT to Dictionary is only supported when the dictionary key is of type \"string\".");
}
elementType = genericArgs[1];
}
UdtMap udtMap = null;
bool readToDictionary;
if (targetTypeIsDictionary)
{
readToDictionary = true;
}
else
{
udtMap = genericSerializer.GetUdtMapByName($"{keyspace}.{name}");
if (udtMap != null)
{
readToDictionary = false;
}
else
{
readToDictionary = true;
elementType = typeof(object);
}
}
var obj = readToDictionary
? ToDictionary(serializer, elementType, (JArray)graphsonObject["definition"], values)
: ToObject(serializer, udtMap, values);
if (!serializer.ConvertFromDb(obj, type, out var result))
{
throw new InvalidOperationException($"Could not convert UDT from type {obj.GetType().FullName} to {type.FullName}");
}
return(result);
}
static void Main()
{
//Zamieniæ to na mysql -- bardzo analogicznie
Cluster cluster = Cluster.Builder()
.AddContactPoint("192.168.100.99")
.Build();
ISession session = cluster.Connect("test_keyspace");
session.UserDefinedTypes.Define(
UdtMap.For <Shot>()
.Map(a => a.id, "id")
.Map(a => a.name, "name")
.Map(a => a.accessible, "accessible")
.Map(a => a.refund, "refund")
);
session.UserDefinedTypes.Define(
UdtMap.For <Patient>()
.Map(a => a.pesel, "pesel")
.Map(a => a.first_name, "first_name")
.Map(a => a.last_name, "last_name")
);
session.UserDefinedTypes.Define(
UdtMap.For <Nurse>()
.Map(a => a.pesel, "pesel")
.Map(a => a.first_name, "first_name")
.Map(a => a.last_name, "last_name")
.Map(a => a.login, "login")
.Map(a => a.password, "password")
);
session.UserDefinedTypes.Define(
UdtMap.For <Doctor>()
.Map(a => a.pesel, "pesel")
.Map(a => a.first_name, "first_name")
.Map(a => a.last_name, "last_name")
.Map(a => a.login, "login")
.Map(a => a.password, "password")
);
session.UserDefinedTypes.Define(
UdtMap.For <Ilness>()
.Map(a => a.id, "id")
.Map(a => a.name, "name")
);
//Zamieniæ to na mysql -- bardzo analogicznie
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
public void Initialize <TUser, TRole>(CassandraOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (string.IsNullOrEmpty(options.KeyspaceName))
{
throw new InvalidOperationException("Keyspace is null or empty.");
}
// Keyspace
_session.CreateKeyspaceIfNotExists(options.KeyspaceName, replication: options.Replication, durableWrites: options.DurableWrites);
_session.ChangeKeyspace(options.KeyspaceName);
// User Defined Types
_session.Execute($"CREATE TYPE IF NOT EXISTS {options.KeyspaceName}.LockoutInfo (EndDate timestamp, Enabled boolean, AccessFailedCount int);");
_session.Execute($"CREATE TYPE IF NOT EXISTS {options.KeyspaceName}.PhoneInfo (Number text, ConfirmationTime timestamp);");
_session.Execute($"CREATE TYPE IF NOT EXISTS {options.KeyspaceName}.LoginInfo (LoginProvider text, ProviderKey text, ProviderDisplayName text);");
_session.Execute($"CREATE TYPE IF NOT EXISTS {options.KeyspaceName}.SimplifiedClaim (Type text, Value text);");
_session.UserDefinedTypes.Define(
UdtMap.For <LockoutInfo>(),
UdtMap.For <PhoneInfo>(),
UdtMap.For <LoginInfo>(),
UdtMap.For <SimplifiedClaim>());
// Tables
var usersTable = new Table <TUser>(_session);
usersTable.CreateIfNotExists();
var rolesTable = new Table <TRole>(_session);
rolesTable.CreateIfNotExists();
// Materialized views
CassandraSessionHelper.UsersTableName = usersTable.GetTable().Name;
CassandraSessionHelper.RolesTableName = rolesTable.GetTable().Name;
_session.Execute("CREATE MATERIALIZED VIEW IF NOT EXISTS users_by_email AS" +
$" SELECT * FROM {options.KeyspaceName}.{CassandraSessionHelper.UsersTableName}" +
" WHERE NormalizedEmail IS NOT NULL" +
" PRIMARY KEY (NormalizedEmail, Id)");
_session.Execute("CREATE MATERIALIZED VIEW IF NOT EXISTS users_by_username AS" +
$" SELECT * FROM {options.KeyspaceName}.{CassandraSessionHelper.UsersTableName}" +
" WHERE NormalizedUserName IS NOT NULL" +
" PRIMARY KEY (NormalizedUserName, Id)");
_session.Execute("CREATE MATERIALIZED VIEW IF NOT EXISTS roles_by_name AS" +
$" SELECT * FROM {options.KeyspaceName}.{CassandraSessionHelper.RolesTableName}" +
" WHERE NormalizedName IS NOT NULL" +
" PRIMARY KEY (NormalizedName, Id)");
}
public UdtMap <TPoco> For <TPoco>(string udtName = null, string keyspace = null) where TPoco : new()
{
if (_definitions.TryGetValue(typeof(TPoco), out var map) == false)
{
map = UdtMap.For <TPoco>(udtName, keyspace);
_definitions.Add(typeof(TPoco), map);
}
return((UdtMap <TPoco>)map);
}
public void MappingNotExistingFieldsTest()
{
var localCluster = Cluster.Builder().AddContactPoint(IpPrefix + "1").Build();
var localSession = localCluster.Connect("tester");
Assert.Throws <InvalidTypeException>(() => localSession.UserDefinedTypes.Define(
//there is no field named like this
UdtMap.For <Phone>("phone").Map(v => v.Number, "Alias_X_WTF")
));
localCluster.Dispose();
}
public void MappingNestedTypeTest()
{
var localSession = GetNewSession(KeyspaceName);
localSession.UserDefinedTypes.Define(
UdtMap.For <Phone>(),
UdtMap.For <Contact>()
.Map(c => c.FirstName, "first_name")
.Map(c => c.LastName, "last_name")
.Map(c => c.Birth, "birth_date")
.Map(c => c.NullableLong, "nullable_long")
);
var insertedContacts = new List <Contact>
{
new Contact
{
FirstName = "Jules", LastName = "Winnfield",
Birth = new DateTimeOffset(1950, 2, 3, 4, 5, 0, 0, TimeSpan.Zero),
NullableLong = null,
Phones = new HashSet <Phone> {
new Phone {
Alias = "home", Number = "123456"
}
}
},
new Contact
{
FirstName = "Mia", LastName = "Wallace",
Birth = null,
NullableLong = 2,
Phones = new HashSet <Phone>
{
new Phone {
Alias = "mobile", Number = "789"
},
new Phone {
Alias = "office", Number = "123"
}
}
}
};
localSession.Execute(new SimpleStatement("INSERT INTO users_contacts (id, contacts) values (?, ?)", 1, insertedContacts));
var rs = localSession.Execute("SELECT * FROM users_contacts WHERE id = 1");
var row = rs.First();
var contacts = row.GetValue <List <Contact> >("contacts");
Assert.NotNull(contacts);
Assert.AreEqual(2, contacts.Count);
Assert.AreEqual(insertedContacts[0], contacts[0]);
Assert.AreEqual(insertedContacts[1], contacts[1]);
}
public async Task MappingDifferentKeyspaceSingleExplicitAsync_AsParameter()
{
const string cqlType1 = "CREATE TYPE phone2 (alias2 text, number2 text, country_code2 int, verified_at timestamp, phone_type text)";
const string cqlTable1 = "CREATE TABLE users2 (id int PRIMARY KEY, main_phone frozen<phone2>)";
var cluster = GetNewTemporaryCluster();
var newKeyspace = TestUtils.GetUniqueKeyspaceName().ToLowerInvariant();
var session = cluster.Connect();
session.CreateKeyspaceIfNotExists(newKeyspace);
session.ChangeKeyspace(newKeyspace);
session.Execute(cqlType1);
session.Execute(cqlTable1);
await session.UserDefinedTypes.DefineAsync(
UdtMap.For <Phone>("phone", KeyspaceName)
.Map(v => v.Alias, "alias")
.Map(v => v.CountryCode, "country_code")
.Map(v => v.Number, "number"),
UdtMap.For <Phone2>("phone2")
.Map(v => v.Alias, "alias2")
.Map(v => v.CountryCode, "country_code2")
.Map(v => v.Number, "number2")
).ConfigureAwait(false);
var phone = new Phone
{
Alias = "home phone",
Number = "85 988888888",
CountryCode = 55
};
var phone2 = new Phone2
{
Alias = "home phone2",
Number = "85 988888811",
CountryCode = 66
};
session.Execute(new SimpleStatement($"INSERT INTO {KeyspaceName}.users (id, main_phone) values (1, ?)", phone));
var rs = session.Execute($"SELECT * FROM {KeyspaceName}.users WHERE id = 1");
var row = rs.First();
var value = row.GetValue <Phone>("main_phone");
session.Execute(new SimpleStatement("INSERT INTO users2 (id, main_phone) values (1, ?)", phone2));
rs = session.Execute("SELECT * FROM users2 WHERE id = 1");
row = rs.First();
var value2 = row.GetValue <Phone2>("main_phone");
Assert.AreEqual(phone, value);
Assert.AreEqual(phone2, value2);
}
public void MappingGetChildClassTest()
{
var localSession = GetNewTemporarySession(KeyspaceName);
var tableName = TestUtils.GetUniqueTableName().ToLowerInvariant();
localSession.Execute($"CREATE TABLE {tableName} (id uuid PRIMARY KEY, main_phone frozen<phone>, phones list<frozen<phone>>)");
localSession.UserDefinedTypes.Define(
UdtMap.For <Phone2>("phone")
.Map(v => v.Alias, "alias")
.Map(v => v.CountryCode, "country_code")
.Map(v => v.Number, "number")
.Map(v => v.VerifiedAt, "verified_at")
.Map(v => v.PhoneType, "phone_type"));
var id = Guid.NewGuid();
var date = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(100000);
var phoneCql = "{alias: 'home phone', number: '123', country_code: 34, verified_at: '100000', phone_type: 'Home'}";
localSession.Execute($"INSERT INTO {tableName} (id, phones, main_phone) values ({id}, [{phoneCql}], {phoneCql})");
var rs = localSession.Execute(new SimpleStatement($"SELECT * FROM {tableName} WHERE id = ?", id));
var row = rs.First();
void AssertAreEqualPhone(Phone v)
{
Assert.AreEqual("home phone", v.Alias);
Assert.AreEqual("123", v.Number);
Assert.AreEqual(34, v.CountryCode);
Assert.AreEqual(date, v.VerifiedAt);
Assert.AreEqual(PhoneType.Home, v.PhoneType);
}
var value = row.GetValue <Phone>("main_phone");
Assert.NotNull(value);
AssertAreEqualPhone(value);
var valueChild = row.GetValue <Phone2>("main_phone");
Assert.NotNull(valueChild);
AssertAreEqualPhone(valueChild);
var valueList = row.GetValue <IEnumerable <Phone> >("phones");
var valueInsideList = valueList.Single();
Assert.NotNull(valueInsideList);
AssertAreEqualPhone(valueInsideList);
var valueListChild = row.GetValue <IEnumerable <Phone2> >("phones");
var valueInsideListChild = valueListChild.Single();
Assert.NotNull(valueInsideListChild);
AssertAreEqualPhone(value);
}
private CassandraDataPointsRepository()
{
try
{
this.executionInstance = new CassandraExecutionInstance(this.server, this.keyspace);
executionInstance.UserDefinedTypeMappings.Define(UdtMap.For <PointDisplacementType>("points_displacements"));
executionInstance.UserDefinedTypeMappings.Define(UdtMap.For <BasePointType>("base_point"));
}
catch (Exception exception)
{
CoreContainers.LogsRepository?.LogError(exception, Core.Database.Logs.LogTrigger.DataAccess);
}
}
public void TokenFrozen()
{
_session.Execute("DROP TYPE IF EXISTS udt");
_session.Execute("CREATE TYPE udt(a int, b text, c float)");
_session.UserDefinedTypes.Define(
UdtMap.For <UDT>("udt")
.Map(v => v.A, "a")
.Map(v => v.B, "b")
.Map(v => v.C, "c")
);
TestToken(typeof(IDictionary <int, string>), typeof(ISet <double>), typeof(IEnumerable <ISet <string> >), typeof(UDT));
}
/// <summary>
/// Adds a UDT mapping definition
/// </summary>
internal void SetUdtMap(string name, UdtMap map)
{
_udtSerializer.SetUdtMap(name, map);
}
