public void BatchMixedStatements() { foreach (var protocolVersion in ProtocolVersionSupported) { //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"); var tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); CreateTable(tableName); var simpleStatement = new SimpleStatement(String.Format("INSERT INTO {0} (id, label, number) VALUES ({1}, {2}, {3})", tableName, 1, "label", 2)); var ps = localSession.Prepare(string.Format(@"INSERT INTO {0} (id, label, number) VALUES (?, ?, ?)", tableName)); var batchStatement = new BatchStatement(); var expectedValues = new List<object[]> {new object[] {1, "label", 2}, new object[] {1, "test", 2}}; batchStatement.Add(ps.Bind(new object[] {1, "test", 2})); batchStatement.Add(simpleStatement); var rs = localSession.Execute("SELECT * FROM " + tableName); VerifyData(rs, expectedValues); } }
public void RequestHandler_GetRequest_BatchStatement_Default_QueryOptions_Are_Used() { var stmt = new BatchStatement(); Assert.Null(stmt.ConsistencyLevel); var request = (BatchRequest)RequestHandler <RowSet> .GetRequest(stmt, new Serializer(2), GetConfig()); Assert.AreEqual(DefaultQueryOptions.GetConsistencyLevel(), request.Consistency); }
public void BatchStatement_Bind_SetsRoutingValues_Single() { var batch = new BatchStatement(); Assert.Null(batch.RoutingKey); batch.SetRoutingValues("id1-value"); batch.Serializer = new SerializerManager(ProtocolVersion.MaxSupported).GetCurrentSerializer(); CollectionAssert.AreEqual(batch.Serializer.Serialize("id1-value"), batch.RoutingKey.RawRoutingKey); }
public BatchStatement GetBatchStatement(ISession session, IEnumerable<Cql> cqlToBatch) { var batch = new BatchStatement(); foreach (var cql in cqlToBatch) { batch.Add(GetStatement(session, cql)); } return batch; }
public void Batch_UsingTwoTables_OneInvalidTable() { var batch = new BatchStatement(); batch.Add(new SimpleStatement($@"INSERT INTO {_tableName} (id, label, number) VALUES ({400}, '{"label1"}', {1})")); batch.Add(new SimpleStatement($@"INSERT INTO table_randomnonexistent (id, label, number) VALUES ({2}, '{"label2"}', {2})")); Assert.Throws <InvalidQueryException>(() => Session.Execute(batch)); }
static void Main(string[] args) { Console.WriteLine("Hello Cassandra World!"); var cluster = Cluster.Builder() .AddContactPoint("192.168.0.40") .Build(); //new TemperatureRepository() var session = cluster.Connect("peiuhub"); System.Diagnostics.Stopwatch watch = System.Diagnostics.Stopwatch.StartNew(); int rowCount = 0; using (StreamReader reader = new StreamReader(sampleFile)) { var track = session.Prepare("INSERT INTO peiuhub.pcs_log2(id, timestamp, pcs_meter, pcs_volt, pcs_current, pcs_status, pv_meter, soc, soh, rcc, source, deviceid) VALUES " + "(?,?,?,?,?,?,?,?,?,?,?,?)"); reader.ReadLine(); var batch = new BatchStatement(); ushort batchCount = 0; while (reader.EndOfStream == false) { string line = reader.ReadLine(); string[] columns = line.Split(','); DateTime time = DateTime.Parse(columns[0]); float pcs_meter = float.Parse(columns[1]); float pcs_volt = float.Parse(columns[2]); float pcs_current = float.Parse(columns[3]); int pcs_status = int.Parse(columns[4]); float pv_meter = float.Parse(columns[5]); float soc = float.Parse(columns[6]); float soh = float.Parse(columns[7]); int rcc = int.Parse(columns[8]); int source = 0; string deviceid = columns[10]; //Int32 unixTimestamp = (Int32)(time.Subtract(new DateTime(1970, 1, 1))).TotalSeconds; Guid id = Guid.NewGuid(); batch.Add(track.Bind(id, time, pcs_meter, pcs_volt, pcs_current, pcs_status, pv_meter, soc, soh, rcc, source, deviceid)); batchCount++; rowCount++; if (rowCount % 200 == 0) { session.Execute(batch); batch = new BatchStatement(); batchCount = 0; } } session.Execute(batch); } Console.WriteLine($"완료. 걸린시간:{watch.Elapsed} row갯수:{rowCount}"); Console.ReadKey(); }
public void RequestHandler_GetRequest_BatchStatement_Statement_Level_Settings_Are_Used() { var stmt = new BatchStatement(); stmt.SetConsistencyLevel(ConsistencyLevel.EachQuorum); Assert.AreEqual(ConsistencyLevel.EachQuorum, stmt.ConsistencyLevel); var request = (BatchRequest)RequestHandler.GetRequest(stmt, Serializer, GetConfig()); Assert.AreEqual(ConsistencyLevel.EachQuorum, request.Consistency); }
public void BatchStatement_Bind_SetsRoutingValues_Single() { const int protocolVersion = 2; var batch = new BatchStatement(); Assert.Null(batch.RoutingKey); batch.SetRoutingValues("id1-value"); batch.ProtocolVersion = protocolVersion; CollectionAssert.AreEqual(TypeCodec.Encode(protocolVersion, "id1-value"), batch.RoutingKey.RawRoutingKey); }
public BatchStatement GetBatchStatement(ISession session, IEnumerable <Cql> cqlToBatch, BatchType batchType) { var batch = new BatchStatement().SetBatchType(batchType); foreach (var cql in cqlToBatch) { batch.Add(GetStatement(session, cql)); } return(batch); }
public void RequestHandler_GetRequest_BatchStatement_Statement_Level_Settings_Are_Used() { var stmt = new BatchStatement(); stmt.SetConsistencyLevel(ConsistencyLevel.EachQuorum); Assert.AreEqual(ConsistencyLevel.EachQuorum, stmt.ConsistencyLevel); var request = (BatchRequest)RequestHandler <RowSet> .GetRequest(stmt, new Serializer(ProtocolVersion.MaxSupported), GetConfig()); Assert.AreEqual(ConsistencyLevel.EachQuorum, request.Consistency); }
public void BatchStatement_Bind_SetsRoutingValues_Single() { const int protocolVersion = 2; var batch = new BatchStatement(); Assert.Null(batch.RoutingKey); batch.SetRoutingValues("id1-value"); batch.Serializer = new Serializer(protocolVersion); CollectionAssert.AreEqual(batch.Serializer.Serialize("id1-value"), batch.RoutingKey.RawRoutingKey); }
public void RequestHandler_GetRequest_BatchStatement_QueryOptions_Are_Used() { var stmt = new BatchStatement(); Assert.Null(stmt.ConsistencyLevel); var queryOptions = new QueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalQuorum); var request = (BatchRequest)RequestHandler.GetRequest(stmt, Serializer, GetConfig(queryOptions)); Assert.AreEqual(queryOptions.GetConsistencyLevel(), request.Consistency); }
public void BatchStatement_Should_Use_Routing_Key_Of_First_Statement_With_SimpleStatement_Instances() { var rawRoutingKey = new byte[] { 1, 2, 3, 4 }; var s1 = new SimpleStatement("Q1").SetRoutingKey(new RoutingKey(rawRoutingKey)); var s2 = new SimpleStatement("Q2").SetRoutingKey(new RoutingKey(new byte[] { 100, 101, 102 })); var batch = new BatchStatement().Add(s1).Add(s2); Assert.AreEqual(BitConverter.ToString(rawRoutingKey), BitConverter.ToString(batch.RoutingKey.RawRoutingKey)); }
public BatchStatement GetBatchStatement(IEnumerable <Cql> cqlToBatch) { var batch = new BatchStatement(); foreach (Cql cql in cqlToBatch) { batch.Add(GetStatement(cql)); } return(batch); }
public void BatchStatement_Default_QueryOptions_Are_Used() { var stmt = new BatchStatement(); Assert.Null(stmt.ConsistencyLevel); var session = GetInstance(); var request = (BatchRequest)session.GetRequest(stmt); Assert.AreEqual(DefaultQueryOptions.GetConsistencyLevel(), request.Consistency); }
public async Task UpdateRoleAsync(CassandraRole role, CancellationToken cancellationToken = default(CancellationToken)) { if (role == null) { throw new ArgumentNullException("role"); } if (string.IsNullOrEmpty(role.Name)) { throw new ArgumentNullException("role", "role.Name cannot be null or empty"); } var modifiedDate = DateTimeOffset.UtcNow; role.Modified = modifiedDate; var batch = new BatchStatement(); string oldName; var changed = role.HasNameChanged(out oldName); if (changed) { // This a Create/Delete move // can only change the name if that target name does not exist. var findResult = await FindRoleByNameAsync(role.Name); if (findResult.Any()) { // sorry, no go, this is record must either be deleted first or use another name. throw new Exception( string.Format( "Cannot change role name:[{0}] to an existing role, pick another name, or delete this one first", role.Name)); } var boundStatements = await BuildCreateStatements(role); batch.AddRange(boundStatements); var oldRole = new CassandraRole(role.TenantId, oldName); boundStatements = await BuildDeleteStatements(oldRole); batch.AddRange(boundStatements); await CassandraSession.ExecuteAsync(batch).ConfigureAwait(false); await RenameRoleNameInUsersAsync(oldName, role.Name, cancellationToken); } else { PreparedStatement[] prepared = await _updateRole; // UPDATE roles ... batch.Add(prepared[0].Bind(role.Name, role.DisplayName, role.IsSystemRole, modifiedDate, role.Id)); // UPDATE roles_by_name ... (since username hasn't changed) batch.Add(prepared[1].Bind(role.DisplayName, role.IsSystemRole, modifiedDate, role.TenantId, role.Name)); await CassandraSession.ExecuteAsync(batch).ConfigureAwait(false); } }
public void BatchStatement_QueryOptions_Are_Used() { var stmt = new BatchStatement(); Assert.Null(stmt.ConsistencyLevel); var queryOptions = new QueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalQuorum); var session = GetInstance(queryOptions); var request = (BatchRequest)session.GetRequest(stmt); Assert.AreEqual(queryOptions.GetConsistencyLevel(), request.Consistency); }
public RowSet InvokeUpdateOrder(object[] parameters) { BatchStatement batch = new BatchStatement(); List <Order> orderProducts = EntityMapper.ToOrders(session.Execute(preparedStatements[Statements.SELECT_ORDER_FROM_ORDER].Bind(parameters))); foreach (Order orderToUpdate in orderProducts) { batch.Add(preparedStatements[Statements.UPDATE_STATUS_ORDER].Bind(parameters[0], parameters[1], orderToUpdate.ProductName)); } return(session.Execute(batch)); }
/// <summary> /// Gets the timestamp of the request or null if not defined. /// </summary> private static long?GetRequestTimestamp(BatchStatement statement, ITimestampGenerator timestampGenerator) { if (statement.Timestamp != null) { return(TypeSerializer.SinceUnixEpoch(statement.Timestamp.Value).Ticks / 10); } var timestamp = timestampGenerator.Next(); return(timestamp != long.MinValue ? (long?)timestamp : null); }
public void BatchStatement_Statement_Level_Settings_Are_Used() { var stmt = new BatchStatement(); stmt.SetConsistencyLevel(ConsistencyLevel.EachQuorum); Assert.AreEqual(ConsistencyLevel.EachQuorum, stmt.ConsistencyLevel); var session = GetInstance(); var request = (BatchRequest)session.GetRequest(stmt); Assert.AreEqual(ConsistencyLevel.EachQuorum, request.Consistency); }
public void Execute(ICqlBatch batch) { if (batch == null) { throw new ArgumentNullException("batch"); } BatchStatement batchStatement = _statementFactory.GetBatchStatement(batch.Statements); _session.Execute(batchStatement); }
public async Task ExecuteAsync(ICqlBatch batch) { if (batch == null) { throw new ArgumentNullException("batch"); } BatchStatement batchStatement = await _statementFactory.GetBatchStatementAsync(batch.Statements); await _session.ExecuteAsync(batchStatement); }
public async Task DeleteAsync(CassandraRole role) { PreparedStatement[] prepared = await _deleteRole; var batch = new BatchStatement(); // DELETE FROM roles ... batch.Add(prepared[0].Bind(role.Id)); // DELETE FROM roles_by_rolename ... batch.Add(prepared[1].Bind(role.Name, role.TenantId)); await _session.ExecuteAsync(batch).ConfigureAwait(false); }
public void Add(Cliente p_cliente) { Guid id = Guid.NewGuid(); LocalDate date = new LocalDate(p_cliente.DataNascimento.Year, p_cliente.DataNascimento.Month, p_cliente.DataNascimento.Day); var userTrackStmt = session.Prepare(@"INSERT INTO cliente (id, nome, email, cpf, datanascimento) VALUES (?, ?, ?, ?, ?)"); var batch = new BatchStatement() .Add(userTrackStmt.Bind(id, p_cliente.Nome, p_cliente.Email, p_cliente.CPF, date)); session.Execute(batch); }
public void BatchStatement_Max_Queries_Test() { var batch = new BatchStatement(); var id = Guid.NewGuid(); for (int i = 0; i < ushort.MaxValue; i++) { batch.Add(new SimpleStatement("QUERY", id)); } // It shouldn't allow more Assert.Throws <ArgumentOutOfRangeException>(() => batch.Add(new SimpleStatement("QUERY", id))); }
public void Batch_Payload_Test() { var outgoing = new Dictionary<string, byte[]> { { "k1-batch", Encoding.UTF8.GetBytes("value1") }, { "k2-batch", Encoding.UTF8.GetBytes("value2") } }; var stmt = new BatchStatement(); stmt.Add(new SimpleStatement(String.Format("INSERT INTO {0} (k, i) VALUES ('one', 1)", Table))); stmt.SetOutgoingPayload(outgoing); var rs = Session.Execute(stmt); Assert.NotNull(rs.Info.IncomingPayload); Assert.AreEqual(outgoing.Count, rs.Info.IncomingPayload.Count); CollectionAssert.AreEqual(outgoing["k1-batch"], rs.Info.IncomingPayload["k1-batch"]); CollectionAssert.AreEqual(outgoing["k2-batch"], rs.Info.IncomingPayload["k2-batch"]); }
public void BatchPreparedStatementsFlagsNotSupportedInC2_0() { var tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); CreateTable(tableName); var ps = Session.Prepare(string.Format(@"INSERT INTO {0} (id, label, number) VALUES (?, ?, ?)", tableName)); var batch = new BatchStatement(); batch.Add(ps.Bind(new object[] { 1, "label1", 1 })); Assert.Throws <NotSupportedException>(() => Session.Execute(batch.SetTimestamp(DateTime.Now))); }
public void Batch_PreparedStatement_AsyncTest() { List<object[]> expectedValues = new List<object[]> { new object[] { 10, "label1", 1 }, new object[] { 11, "label2", 2 }, new object[] { 12, "label3", 3 } }; PreparedStatement ps = Session.Prepare(string.Format(@"INSERT INTO {0} (id, label, number) VALUES (?, ?, ?)", _tableName)); BatchStatement batch = new BatchStatement(); foreach (object[] val in expectedValues) { batch.Add(ps.Bind(val)); } Assert.DoesNotThrow(() => Session.ExecuteAsync(batch).Wait()); }
public string RegisterNewUser([FromBody] User user) { ISession session = SessionManager.GetSession(); if (session == null) { return("Session error"); } HttpPostedFileBase user_image = Request.Files["user_image_blob"]; byte[] user_image_blob = null; if (user_image != null) { if (user_image.ContentType != "image/jpeg") { return("file format error"); } user_image_blob = new byte[user_image.ContentLength]; user_image.InputStream.Read(user_image_blob, 0, user_image.ContentLength); } if (user.profile_description == null) { user.profile_description = ""; } var st = session.Prepare("insert into \"user\" (user_image_blob, user_name, full_name, profile_description, user_password)" + "values (?,?,?,?,?)"); var statement = st.Bind(user_image_blob, user.user_name.ToLower(), user.full_name, user.profile_description, user.user_password); var st3 = session.Prepare("UPDATE user_stats SET number_of_followers = number_of_followers + 0, number_of_following = number_of_following + 0, number_of_posts = number_of_posts + 0 " + "WHERE user_name = ?"); var statement3 = st3.Bind(user.user_name.ToLower()); var batch = new BatchStatement() .Add(statement); RowSet newUser = session.Execute(batch); RowSet updateResult = session.Execute(statement3); if (newUser.IsFullyFetched && updateResult.IsFullyFetched) { return("success"); } else { return("Writing error."); } }
public string FollowUser() { ISession session = SessionManager.GetSession(); if (Session["user_name"] == null) { return("you muste be logged in"); } if (session == null) { return("DB error"); } byte[] following_image_blob = null; if (Request["following_image_blob"] != null) { following_image_blob = Convert.FromBase64String(Request["following_image_blob"]); } //insert into the people i follow var st = session.Prepare("INSERT INTO people_i_follow(user_name, following_user_name, following_full_name, following_image_blob)" + "VALUES(?, ?, ?, ?)"); var statement = st.Bind(Session["user_name"], Request["following_user_name"], Request["following_full_name"], following_image_blob); //update number of people i follow var st2 = session.Prepare("UPDATE user_stats SET number_of_following = number_of_following + 1 WHERE user_name = ?"); var statement2 = st2.Bind(Session["user_name"]); //insert me into that persons followers var st3 = session.Prepare("INSERT INTO my_followers(user_name, follower_user_name, follower_full_name, follower_image_blob)" + "VALUES(?, ?, ?, ?)"); var statement3 = st3.Bind(Request["following_user_name"], Session["user_name"], Session["full_name"], Session["user_image_blob"]); //update that persons number of followers var st4 = session.Prepare("UPDATE user_stats SET number_of_followers = number_of_followers + 1 WHERE user_name = ?"); var statement4 = st4.Bind(Request["following_user_name"]); var batch = new BatchStatement() .Add(statement) .Add(statement3); RowSet result = session.Execute(batch); RowSet updateStas = session.Execute(statement2); RowSet updateStas2 = session.Execute(statement4); if (result.IsFullyFetched && updateStas.IsFullyFetched && updateStas2.IsFullyFetched) { return("success"); } else { return("error"); } }
public void CreateFolder(InventoryFolder folder) { var skelInsert = SKEL_INSERT_STMT.Bind(folder.OwnerId, folder.FolderId, folder.Name, folder.ParentId, folder.Type, (int)folder.Level); var contentInsert = FOLDER_ATTRIB_INSERT_STMT.Bind(folder.FolderId, FOLDER_MAGIC_ENTRY, folder.Name, folder.Type, UnixTimeNow(), folder.OwnerId); var batch = new BatchStatement() .Add(skelInsert) .Add(contentInsert); _session.Execute(batch); VersionInc(folder.OwnerId, folder.FolderId); }
public void SaveFolder(InventoryFolder folder) { var skelUpdate = SKEL_UPDATE_STMT.Bind(folder.Name, folder.Type, folder.OwnerId, folder.FolderId); var contentUpdate = FOLDER_UPDATE_STMT.Bind(folder.Name, folder.Type, folder.FolderId); var batch = new BatchStatement() .Add(skelUpdate) .Add(contentUpdate); _session.Execute(batch); VersionInc(folder.OwnerId, folder.FolderId); }
private void DeleteFolder(Guid ownerId, Guid folderId) { var folderRemove = FOLDER_REMOVE_STMT.Bind(folderId); var skelRemove = SKEL_REMOVE_STMT.Bind(ownerId, folderId); var versionRemove = FOLDER_VERSION_REMOVE_STMT.Bind(ownerId, folderId); var batch = new BatchStatement() .Add(folderRemove) .Add(skelRemove); _session.Execute(batch); _session.Execute(versionRemove); }
public void PurgeItem(InventoryItem item) { var removeItem = FOLDER_ITEM_REMOVE_STMT.Bind(item.FolderId, item.ItemId); var removeOwnership = ITEM_OWNERSHIP_REMOVE.Bind(item.ItemId); var batch = new BatchStatement() .Add(removeItem) .Add(removeOwnership); _session.Execute(batch); VersionInc(item.OwnerId, item.FolderId); }
public void Batch_SimpleStatementSingle() { var tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); CreateTable(tableName); var batch = new BatchStatement(); var simpleStatement = new SimpleStatement(String.Format("INSERT INTO {0} (id, label, number) VALUES ({1}, '{2}', {3})", _tableName, 20, "label 20", 20)); batch.Add(simpleStatement); Session.Execute(batch); //Verify Results var rs = Session.Execute(String.Format("SELECT * FROM {0} WHERE id IN ({1})", _tableName, 20)); var row = rs.First(); CollectionAssert.AreEqual(row, new object[] { 20, "label 20", 20}); }
public void Batch_PreparedStatement() { List<object[]> expectedValues = new List<object[]> { new object[] { 1, "label1", 1 }, new object[] { 2, "label2", 2 }, new object[] { 3, "label3", 3 } }; PreparedStatement ps = Session.Prepare(string.Format(@"INSERT INTO {0} (id, label, number) VALUES (?, ?, ?)", _tableName)); BatchStatement batch = new BatchStatement(); foreach (object[] val in expectedValues) { batch.Add(ps.Bind(val)); } Session.Execute(batch); // Verify results var rs = Session.Execute(String.Format("SELECT * FROM {0} WHERE id IN ({1}, {2}, {3})", _tableName, 1, 2, 3)); VerifyData(rs, expectedValues); }
public Task<BatchStatement> GetBatchStatementAsync(ISession session, IEnumerable<Cql> cqlToBatch) { // Get all the statements async in parallel, then add to batch return Task.Factory.ContinueWhenAll(cqlToBatch.Select(cql => GetStatementAsync(session, cql)).ToArray(), (tasks) => { var batch = new BatchStatement(); foreach (var t in tasks) { if (t.Exception != null) { throw t.Exception; } batch.Add(t.Result); } return batch; }, TaskContinuationOptions.ExecuteSynchronously); }
public void BatchPreparedStatementBasicAsyncTest() { string tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); List<object[]> expectedValues = new List<object[]> { new object[] { 1, "label1", 1 }, new object[] { 2, "label2", 2 }, new object[] { 3, "label3", 3 } }; CreateTable(tableName); PreparedStatement ps = Session.Prepare(string.Format(@"INSERT INTO {0} (id, label, number) VALUES (?, ?, ?)", tableName)); BatchStatement batch = new BatchStatement(); foreach (object[] val in expectedValues) { batch.Add(ps.Bind(val)); } var task = Session.ExecuteAsync(batch); var rs = task.Result; // Verify results VerifyData(rs, expectedValues); }
public BatchRequest(int protocolVersion, BatchStatement statement, ConsistencyLevel consistency) { ProtocolVersion = protocolVersion; if (ProtocolVersion < 2) { throw new NotSupportedException("Batch request is supported in C* >= 2.0.x"); } _type = statement.BatchType; _requests = statement.Queries .Select(q => q.CreateBatchRequest(ProtocolVersion)) .ToArray(); Consistency = consistency; _timestamp = statement.Timestamp; if (statement.IsTracing) { _headerFlags = FrameHeader.HeaderFlag.Tracing; } if (statement.SerialConsistencyLevel != ConsistencyLevel.Any) { if (protocolVersion < 3) { throw new NotSupportedException("Serial consistency level for BATCH request is supported in Cassandra 2.1 or above."); } if (statement.SerialConsistencyLevel < ConsistencyLevel.Serial) { throw new RequestInvalidException("Non-serial consistency specified as a serial one."); } _batchFlags |= QueryProtocolOptions.QueryFlags.WithSerialConsistency; _serialConsistency = statement.SerialConsistencyLevel; } if (_timestamp != null) { if (protocolVersion < 3) { throw new NotSupportedException("Timestamp for BATCH request is supported in Cassandra 2.1 or above."); } _batchFlags |= QueryProtocolOptions.QueryFlags.WithDefaultTimestamp; } }
public void LinqUpdate_Batch() { // Setup Table<Movie> table = new Table<Movie>(_session, new MappingConfiguration()); table.CreateIfNotExists(); Movie movieToUpdate1 = _movieList[1]; Movie movieToUpdate2 = _movieList[2]; BatchStatement batch = new BatchStatement(); var expectedMovie1 = new Movie(movieToUpdate1.Title, movieToUpdate1.Director, "something_different_" + Randomm.RandomAlphaNum(10), movieToUpdate1.MovieMaker, 1212); var update1 = table.Where(m => m.Title == movieToUpdate1.Title && m.MovieMaker == movieToUpdate1.MovieMaker && m.Director == movieToUpdate1.Director) .Select(m => new Movie { Year = expectedMovie1.Year, MainActor = expectedMovie1.MainActor }) .Update(); batch.Add(update1); var expectedMovie2 = new Movie(movieToUpdate2.Title, movieToUpdate2.Director, "also_something_different_" + Randomm.RandomAlphaNum(10), movieToUpdate2.MovieMaker, 1212); var update2 = table.Where(m => m.Title == movieToUpdate2.Title && m.MovieMaker == movieToUpdate2.MovieMaker && m.Director == movieToUpdate2.Director) .Select(m => new Movie { Year = expectedMovie2.Year, MainActor = expectedMovie2.MainActor }) .Update(); batch.Add(update2); table.GetSession().Execute(batch); List<Movie> actualMovieList = table.Execute().ToList(); Assert.AreEqual(_movieList.Count, actualMovieList.Count()); Assert.AreNotEqual(expectedMovie1.MainActor, expectedMovie2.MainActor); Assert.IsFalse(Movie.ListContains(_movieList, expectedMovie1)); Assert.IsFalse(Movie.ListContains(_movieList, expectedMovie2)); Movie.AssertListContains(actualMovieList, expectedMovie1); Movie.AssertListContains(actualMovieList, expectedMovie2); }
public void NestedCollections_BatchStatements() { using (var session = Cluster.Builder().AddContactPoint(TestCluster.InitialContactPoint).Build().Connect()) { string keyspaceName = TestUtils.GetUniqueKeyspaceName().ToLower(); string fqTableName = keyspaceName + "." + TestUtils.GetUniqueKeyspaceName().ToLower(); SetupForFrozenNestedCollectionTest(session, keyspaceName, fqTableName); var cqlInsertStr = String.Format("INSERT INTO {0} (id, map1, map2, list1) VALUES (?, ?, ?, ?)", fqTableName); PreparedStatement preparedStatement = session.Prepare(cqlInsertStr); BatchStatement batchStatement = new BatchStatement(); var map1Value = GetMap1Val(); var map2Value = GetMap2Val(); var list1Value = GetList1Val(); // Insert batchStatement.Add(preparedStatement.Bind(1, map1Value, map2Value, list1Value)); session.Execute(batchStatement); // Validate the end state of data in C* string cqlSelectStr = String.Format("SELECT id, map1, map2, list1 FROM {0} WHERE id = 1", fqTableName); PreparedStatement preparedSelect = session.Prepare(cqlSelectStr); var row = session.Execute(preparedSelect.Bind(new object[] { })).First(); ValidateSelectedNestedFrozenRow(row); } }
public void RequestHandler_GetRequest_BatchStatement_Statement_Level_Settings_Are_Used() { var stmt = new BatchStatement(); stmt.SetConsistencyLevel(ConsistencyLevel.EachQuorum); Assert.AreEqual(ConsistencyLevel.EachQuorum, stmt.ConsistencyLevel); var request = (BatchRequest)RequestHandler<RowSet>.GetRequest(stmt, 2, GetConfig()); Assert.AreEqual(ConsistencyLevel.EachQuorum, request.Consistency); }
public void BatchSerialConsistencyTest() { var tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); CreateTable(tableName); var query = new SimpleStatement(String.Format("INSERT INTO {0} (id) values (-99999)", tableName)); Assert.Throws<ArgumentException>(() => { //You can not specify local serial consistency as a valid read one. var batch = new BatchStatement() .Add(query) .SetBatchType(BatchType.Logged) .SetSerialConsistencyLevel(ConsistencyLevel.Quorum); Session.Execute(batch); }); //It should work var statement = new BatchStatement() .Add(query) .SetConsistencyLevel(ConsistencyLevel.Quorum) .SetSerialConsistencyLevel(ConsistencyLevel.LocalSerial); //Read consistency specified and write consistency specified Session.Execute(statement); }
public void BatchSimpleStatementMultiple() { SimpleStatement simpleStatement = null; var tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); var expectedValues = new List<object[]>(); CreateTable(tableName); BatchStatement batch = new BatchStatement(); for(var x = 1; x <= 5; x++) { simpleStatement = new SimpleStatement(String.Format("INSERT INTO {0} (id, label, number) VALUES ({1}, '{2}', {3})", tableName, x, "label" + x, x * x)); expectedValues.Add(new object[] { x, "label" + x, x * x }); batch.Add(simpleStatement); } Session.Execute(batch); var rs = Session.Execute("SELECT * FROM " + tableName); VerifyData(rs.OrderBy(r => r.GetValue<int>("id")), expectedValues); }
public void BatchSimpleStatementSingleBinded() { var tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); CreateTable(tableName); var batch = new BatchStatement(); var simpleStatement = new SimpleStatement(String.Format("INSERT INTO {0} (id, label, number) VALUES (?, ?, ?)", tableName)); batch.Add(simpleStatement.Bind(100, "label 100", 10000)); Session.Execute(batch); //Verify Results var rs = Session.Execute("SELECT * FROM " + tableName); var row = rs.First(); Assert.True(row != null, "There should be a row stored."); Assert.True(row.SequenceEqual(new object[] { 100, "label 100", 10000}), "Stored values dont match"); }
public void BatchStatementOnTwoTablesWithOneInvalidTableTest() { var batch = new BatchStatement(); var tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); CreateTable(tableName); batch.Add(new SimpleStatement(String.Format(@"INSERT INTO {0} (id, label, number) VALUES ({1}, '{2}', {3})", tableName, 1, "label1", 1))); batch.Add(new SimpleStatement(String.Format(@"INSERT INTO table2 (id, label, number) VALUES ({0}, '{1}', {2})", 2, "label2", 2))); Assert.Throws<InvalidQueryException>( delegate { Session.Execute(batch); }, "expected InvalidQueryException, but did not get one"); }
public void BatchStatementTwoTablesTest() { var expectedValues = new List<object[]>(); var batch = new BatchStatement(); CreateTwoTableTestEnv("table1", "table2"); batch.Add(new SimpleStatement(String.Format(@"INSERT INTO table1 (id, label, number) VALUES ({0}, '{1}', {2})", 1, "label1", 1))); batch.Add(new SimpleStatement(String.Format(@"INSERT INTO table2 (id, label, number) VALUES ({0}, '{1}', {2})", 2, "label2", 2))); Session.Execute(batch); //Verify Results RowSet rsTable1 = Session.Execute("SELECT * FROM table1"); VerifyData(rsTable1, new List<object[]> {new object[] { 1, "label1", 1 } }); RowSet rsTable2 = Session.Execute("SELECT * FROM table2"); VerifyData(rsTable2, new List<object[]> { new object[] { 2, "label2", 2 } }); }
public void RequestHandler_GetRequest_BatchStatement_QueryOptions_Are_Used() { var stmt = new BatchStatement(); Assert.Null(stmt.ConsistencyLevel); var queryOptions = new QueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalQuorum); var request = (BatchRequest)RequestHandler<RowSet>.GetRequest(stmt, 2, GetConfig(queryOptions)); Assert.AreEqual(queryOptions.GetConsistencyLevel(), request.Consistency); }
public void LargeBatchPreparedStatement() { string tableName = "table" + Guid.NewGuid().ToString("N"); CreateTable(tableName); PreparedStatement ps = Session.Prepare(String.Format(@"INSERT INTO {0} (id, label, number) VALUES (?, ?, ?)", tableName)); BatchStatement batch = new BatchStatement(); List<object[]> expectedValues = new List<object[]>(); int numberOfPreparedStatements = 100; for (var x = 1; x <= numberOfPreparedStatements; x++) { expectedValues.Add(new object[] { x, "value" + x, x }); batch.Add(ps.Bind(new object[] { x, "value" + x , x })); } Session.Execute(batch); // Verify correct values RowSet rs = Session.Execute("SELECT * FROM " + tableName); VerifyData(rs.OrderBy(r => r.GetValue<int>("id")), expectedValues); }
public void BatchTimestampTest() { var tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); CreateTable(tableName); var query = new SimpleStatement(String.Format("INSERT INTO {0} (id) values (-99999)", tableName)); Assert.DoesNotThrow(() => { //It should work var statement = new BatchStatement() .Add(query) .SetConsistencyLevel(ConsistencyLevel.Quorum) .SetTimestamp(DateTime.Now); //Read consistency specified and write consistency specified Session.Execute(statement); }); }
public void BatchPreparedStatementsFlagsNotSupportedInC2_0() { var tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); CreateTable(tableName); var ps = Session.Prepare(string.Format(@"INSERT INTO {0} (id, label, number) VALUES (?, ?, ?)", tableName)); var batch = new BatchStatement(); batch.Add(ps.Bind(new object[] { 1, "label1", 1 })); Assert.Throws<NotSupportedException>(() => Session.Execute(batch.SetTimestamp(DateTime.Now))); }
public void RequestHandler_GetRequest_BatchStatement_Default_QueryOptions_Are_Used() { var stmt = new BatchStatement(); Assert.Null(stmt.ConsistencyLevel); var request = (BatchRequest)RequestHandler<RowSet>.GetRequest(stmt, 2, GetConfig()); Assert.AreEqual(DefaultQueryOptions.GetConsistencyLevel(), request.Consistency); }
public void BatchPreparedStatementsNotSupportedInC1_2() { string tableName = "table" + Guid.NewGuid().ToString("N").ToLower(); CreateTable(tableName); var ps = Session.Prepare(string.Format(@"INSERT INTO {0} (id, label, number) VALUES (?, ?, ?)", tableName)); BatchStatement batch = new BatchStatement(); batch.Add(ps.Bind(new object[] { 1, "label1", 1 })); try { Session.Execute(batch); Assert.Fail("Cassandra version below 2.0, should not execute batches of prepared statements"); } catch (NotSupportedException ex) { //This is OK Assert.True(ex.Message.ToLower().Contains("batch")); } }
public void BatchStatement_Bind_SetsRoutingValues_Multiple() { const int protocolVersion = 2; var batch = new BatchStatement(); Assert.Null(batch.RoutingKey); batch.SetRoutingValues("id11", "id22"); batch.ProtocolVersion = protocolVersion; var expectedRoutingKey = new byte[0] .Concat(new byte[] { 0, 4 }) .Concat(TypeCodec.Encode(protocolVersion, "id11")) .Concat(new byte[] { 0 }) .Concat(new byte[] { 0, 4 }) .Concat(TypeCodec.Encode(protocolVersion, "id22")) .Concat(new byte[] { 0 }); CollectionAssert.AreEqual(expectedRoutingKey, batch.RoutingKey.RawRoutingKey); }
/////////////////////////////////////// /// Test Helper Methods /////////////////////////////////////// private void DoBatchInsertTest(ConsistencyLevel expectedConsistencyLevel) { // Add a few more records via batch statement BatchStatement batch = new BatchStatement(); batch.SetConsistencyLevel(expectedConsistencyLevel); var addlPocoList = ManyDataTypesEntity.GetDefaultAllDataTypesList(); foreach (var manyDataTypesPoco in addlPocoList) { string simpleStatementStr = GetSimpleStatementInsertString(manyDataTypesPoco); SimpleStatement simpleStatement = new SimpleStatement(simpleStatementStr); batch.Add(simpleStatement); } // Validate Results var result = _session.Execute(batch); Assert.AreEqual(expectedConsistencyLevel, result.Info.AchievedConsistency); int totalExpectedRecords = _defaultPocoList.Count + addlPocoList.Count; result = _session.Execute(_defaultSelectStatement); Assert.AreEqual(totalExpectedRecords, result.GetRows().ToList().Count); }