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