public async Task BasicFlow() { //Assume const string insertCql = @"insert into Test.BasicFlow (id,value) values (?,?);"; const string retrieveCql = @"select * from Test.BasicFlow;"; const int insertCount = 1000; //Act using (var connection = new CqlConnection(ConnectionString)) { await connection.OpenAsync(); var executions = new Task <ICqlQueryResult> [insertCount]; var options = new ParallelOptions() { MaxDegreeOfParallelism = 1 }; Parallel.For(0, insertCount, options, (i) => { var cmd = new CqlCommand(connection, insertCql, CqlConsistency.One); cmd.Prepare(); var b = new BasicFlowData { Id = i, Data = "Hallo " + i }; cmd.PartitionKey.Set(b); cmd.Parameters.Set(b); executions[i] = cmd.ExecuteNonQueryAsync(); }); await Task.WhenAll(executions); var presence = new bool[insertCount]; var selectCmd = new CqlCommand(connection, retrieveCql, CqlConsistency.One) { EnableTracing = true }; CqlDataReader <BasicFlowData> reader = await selectCmd.ExecuteReaderAsync <BasicFlowData>(); while (await reader.ReadAsync()) { BasicFlowData row = reader.Current; Assert.AreEqual(row.Data, "Hallo " + row.Id); presence[row.Id] = true; } Assert.IsTrue(presence.All(p => p)); var tracer = new QueryTraceCommand(connection, reader.TracingId.Value); TracingSession session = await tracer.GetTraceSessionAsync(); Assert.IsNotNull(session); } }
/// <summary> /// Executes a query. /// </summary> /// <param name="connection">The connection.</param> /// <param name="cql">The CQL.</param> /// <param name="logger">The logger.</param> /// <returns> /// A CqlDataReader that can be used to access the query results /// </returns> private async Task <CqlDataReader> ExecQuery(Connection connection, string cql, Logger logger) { logger.LogVerbose("Excuting query {0} on {1}", cql, connection); var query = new QueryFrame(cql, CqlConsistency.One); var result = (ResultFrame)await connection.SendRequestAsync(query, logger).ConfigureAwait(false); var reader = new CqlDataReader(result); logger.LogVerbose("Query {0} returned {1} results", cql, reader.Count); return(reader); }
/// <summary> /// Gets the trace session async. /// </summary> /// <returns> TracingSession if any, null otherwise </returns> public async Task <TracingSession> GetTraceSessionAsync() { TracingSession session = null; var sessionCmd = new CqlCommand(_connection, "select * from system_traces.sessions where session_id=" + _tracingId.ToString() + ";", CqlConsistency.One); using (CqlDataReader <TracingSession> reader = await sessionCmd.ExecuteReaderAsync <TracingSession>().ConfigureAwait(false)) { if (await reader.ReadAsync().ConfigureAwait(false)) { session = reader.Current; } else { return(null); } } var eventsCmd = new CqlCommand(_connection, "select * from system_traces.events where session_id=" + _tracingId.ToString() + ";", CqlConsistency.One); using (CqlDataReader <TracingEvent> reader = await eventsCmd.ExecuteReaderAsync <TracingEvent>().ConfigureAwait(false)) { var events = new List <TracingEvent>(reader.Count); while (await reader.ReadAsync().ConfigureAwait(false)) { events.Add(reader.Current); } session.Events = events; } return(session); }
/// <summary> /// Executes a query. /// </summary> /// <param name="connection">The connection.</param> /// <param name="cql">The CQL.</param> /// <param name="logger">The logger.</param> /// <returns> /// A CqlDataReader that can be used to access the query results /// </returns> private async Task<CqlDataReader> ExecQuery(Connection connection, string cql, Logger logger) { logger.LogVerbose("Excuting query {0} on {1}", cql, connection); var query = new QueryFrame(cql, CqlConsistency.One); var result = (ResultFrame)await connection.SendRequestAsync(query, logger).ConfigureAwait(false); var reader = new CqlDataReader(result); logger.LogVerbose("Query {0} returned {1} results", cql, reader.Count); return reader; }
/// <summary> /// Executes a query. /// </summary> /// <param name="connection"> The connection. </param> /// <param name="cql"> The CQL. </param> /// <param name="logger"> The logger. </param> /// <param name="token"> The token. </param> /// <returns> A CqlDataReader that can be used to access the query results </returns> private async Task<CqlDataReader> ExecQuery(Connection connection, string cql, Logger logger, CancellationToken token) { //cancel if requested token.ThrowIfCancellationRequested(); logger.LogVerbose("Excuting query {0} on {1}", cql, connection); var query = new QueryFrame(cql, CqlConsistency.One, null); var result = (ResultFrame) await connection.SendRequestAsync(query, logger, 1, token) .AutoConfigureAwait(); var reader = new CqlDataReader(null, result, null); logger.LogVerbose("Query {0} returned {1} results", cql, reader.Count); return reader; }
private Node GetNodeFromDataReader(CqlDataReader reader, Logger logger) { //get address of new node, and fallback to listen_address when address is set to any var address = reader.GetIPAddress(reader.GetOrdinal("rpc_address")); if(address == null || address.Equals(IPAddress.Any)) address = reader.GetIPAddress(reader.GetOrdinal("peer")); var dc = reader.GetString(reader.GetOrdinal("data_center")); var rack = reader.GetString(reader.GetOrdinal("rack")); //check if we have an address, otherwise ignore if(address == null || dc == null || rack == null) { logger.LogError("Incomplete node information retrieved for a node: address={0}, dc={1}, rack={2}", address != null ? address.ToString() : "(address not found!)", dc ?? "(datacenter not found)", rack ?? "(rack not found)"); return null; } //get tokens var tokens = (reader.GetSet<string>(reader.GetOrdinal("tokens"))) ?? new HashSet<string>(); //distill protocol version from release version var release = reader.GetString(reader.GetOrdinal("release_version")); byte protocolVersion = DistillProtocolVersion(release); //create a new node return new Node(address, this) { DataCenter = dc, Rack = rack, Tokens = tokens, ProtocolVersion = protocolVersion }; }