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); }