private async Task SendJsonMessageAsync <T>(T message)
{
var queryProtocolOptions = new QueryProtocolOptions(
ConsistencyLevel.One,
new object[] { JsonConvert.SerializeObject(message, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}) },
false,
0,
null,
ConsistencyLevel.Any);
var response = await RunWithTokenAsync(() =>
_cluster.Metadata.ControlConnection.UnsafeSendQueryRequestAsync(
InsightsClient.ReportInsightRpc,
queryProtocolOptions)).ConfigureAwait(false);
if (response == null)
{
throw new DriverInternalError("Received null response.");
}
if (!(response is ResultResponse resultResponse))
{
throw new DriverInternalError("Expected ResultResponse but received: " + response.GetType());
}
if (resultResponse.Kind != ResultResponse.ResultResponseKind.Void)
{
throw new DriverInternalError("Expected ResultResponse of Kind \"Void\" but received: " + resultResponse.Kind);
}
}
public QueryRequest(int protocolVersion, string cqlQuery, bool tracingEnabled, QueryProtocolOptions queryOptions)
{
//TODO: Replace constructor parameters with IStatement
ProtocolVersion = protocolVersion;
_cqlQuery = cqlQuery;
_queryOptions = queryOptions;
if (tracingEnabled)
{
_headerFlags = FrameHeader.HeaderFlag.Tracing;
}
if (queryOptions == null)
{
throw new ArgumentNullException("queryOptions");
}
if (Consistency.IsSerialConsistencyLevel())
{
throw new RequestInvalidException("Serial consistency specified as a non-serial one.");
}
if (queryOptions.SerialConsistency != ConsistencyLevel.Any && queryOptions.SerialConsistency.IsSerialConsistencyLevel() == false)
{
throw new RequestInvalidException("Non-serial consistency specified as a serial one.");
}
if (protocolVersion < 3)
{
//Features supported in protocol v3 and above
if (queryOptions.Timestamp != null)
{
throw new NotSupportedException("Timestamp for query is supported in Cassandra 2.1 and above.");
}
if (queryOptions.ValueNames != null && queryOptions.ValueNames.Count > 0)
{
throw new NotSupportedException("Query parameter names feature is supported in Cassandra 2.1 and above.");
}
}
}
public void Execute_Prepared_With_Param_Test()
{
using (var connection = CreateConnection())
{
connection.Open().Wait();
var prepareRequest = new PrepareRequest(GetSerializer(), "SELECT * FROM system.local WHERE key = ?", null, null);
var task = connection.Send(prepareRequest);
var prepareOutput = ValidateResult <OutputPrepared>(task.Result);
var options = new QueryProtocolOptions(ConsistencyLevel.One, new object[] { "local" }, false, 100, null, ConsistencyLevel.Any);
var executeRequest = new ExecuteRequest(
GetSerializer(),
prepareOutput.QueryId,
null,
new ResultMetadata(prepareOutput.ResultMetadataId, prepareOutput.ResultRowsMetadata),
options,
false,
null);
task = connection.Send(executeRequest);
var output = ValidateResult <OutputRows>(task.Result);
var rows = output.RowSet.ToList();
Assert.Greater(rows.Count, 0);
Assert.NotNull(rows[0].GetValue <string>("key"), "It should contain a key column value");
}
}
public ExecuteRequest(int protocolVersion, byte[] id, RowSetMetadata metadata, bool tracingEnabled, QueryProtocolOptions queryOptions)
{
ProtocolVersion = protocolVersion;
if (metadata != null && queryOptions.Values.Length != metadata.Columns.Length)
{
throw new ArgumentException("Number of values does not match with number of prepared statement markers(?).", "values");
}
_id = id;
_metadata = metadata;
_queryOptions = queryOptions;
if (tracingEnabled)
{
_headerFlags = FrameHeader.HeaderFlag.Tracing;
}
if (Consistency.IsSerialConsistencyLevel())
{
throw new RequestInvalidException("Serial consistency specified as a non-serial one.");
}
if (queryOptions.SerialConsistency != ConsistencyLevel.Any && queryOptions.SerialConsistency.IsSerialConsistencyLevel() == false)
{
throw new RequestInvalidException("Non-serial consistency specified as a serial one.");
}
if (queryOptions.Timestamp != null && protocolVersion < 3)
{
throw new NotSupportedException("Timestamp for query is supported in Cassandra 2.1 or above.");
}
}
public QueryRequest(int protocolVersion, string cqlQuery, bool tracingEnabled, QueryProtocolOptions queryOptions)
{
_cqlQuery = cqlQuery;
_queryOptions = queryOptions;
if (tracingEnabled)
{
_headerFlags = FrameHeader.HeaderFlag.Tracing;
}
if (queryOptions == null)
{
throw new ArgumentNullException("queryOptions");
}
if (queryOptions.SerialConsistency != ConsistencyLevel.Any && queryOptions.SerialConsistency.IsSerialConsistencyLevel() == false)
{
throw new RequestInvalidException("Non-serial consistency specified as a serial one.");
}
if (protocolVersion < 3)
{
//Features supported in protocol v3 and above
if (queryOptions.Timestamp != null)
{
throw new NotSupportedException("Timestamp for query is supported in Cassandra 2.1 and above.");
}
if (queryOptions.ValueNames != null && queryOptions.ValueNames.Count > 0)
{
throw new NotSupportedException("Query parameter names feature is supported in Cassandra 2.1 and above.");
}
}
}
public ExecuteRequest(int protocolVersion, byte[] id, RowSetMetadata metadata, bool tracingEnabled, QueryProtocolOptions queryOptions)
{
ProtocolVersion = protocolVersion;
if (metadata != null && queryOptions.Values.Length != metadata.Columns.Length)
{
throw new ArgumentException("Number of values does not match with number of prepared statement markers(?).", "values");
}
_id = id;
_metadata = metadata;
_queryOptions = queryOptions;
if (tracingEnabled)
{
_headerFlags = FrameHeader.HeaderFlag.Tracing;
}
if (Consistency.IsSerialConsistencyLevel())
{
throw new RequestInvalidException("Serial consistency specified as a non-serial one.");
}
if (queryOptions.SerialConsistency != ConsistencyLevel.Any && queryOptions.SerialConsistency.IsSerialConsistencyLevel() == false)
{
throw new RequestInvalidException("Non-serial consistency specified as a serial one.");
}
if (queryOptions.Timestamp != null && protocolVersion < 3)
{
throw new NotSupportedException("Timestamp for query is supported in Cassandra 2.1 or above.");
}
}
private QueryRequest GetQueryRequest(string query = BasicQuery, QueryProtocolOptions options = null)
{
if (options == null)
{
options = QueryProtocolOptions.Default;
}
return(new QueryRequest(GetSerializer(), query, options, false, null));
}
private QueryRequest GetQueryRequest(string query = BasicQuery, QueryProtocolOptions options = null)
{
if (options == null)
{
options = QueryProtocolOptions.Default;
}
return(new QueryRequest(GetProtocolVersion(), query, false, options));
}
private Task <Response> Query(Connection connection, string query, QueryProtocolOptions options = null)
{
if (options == null)
{
options = QueryProtocolOptions.Default;
}
var request = new QueryRequest(GetLatestProtocolVersion(), query, false, options);
return(connection.Send(request));
}
public QueryRequest(int streamId, string cqlQuery, bool tracingEnabled, QueryProtocolOptions queryPrtclOptions,
ConsistencyLevel?consistency = null)
{
_streamId = streamId;
_cqlQuery = cqlQuery;
_consistency = consistency;
_queryProtocolOptions = queryPrtclOptions;
if (tracingEnabled)
{
_headerFlags = 0x02;
}
}
/// <summary>
/// Gets the Request to send to a cassandra node based on the statement type
/// </summary>
internal static IRequest GetRequest(IStatement statement, ISerializer serializer, IRequestOptions requestOptions)
{
ICqlRequest request = null;
if (statement.IsIdempotent == null)
{
statement.SetIdempotence(requestOptions.DefaultIdempotence);
}
if (statement is RegularStatement s1)
{
s1.Serializer = serializer;
var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s1, requestOptions, null);
options.ValueNames = s1.QueryValueNames;
request = new QueryRequest(serializer, s1.QueryString, options, s1.IsTracing, s1.OutgoingPayload);
}
if (statement is BoundStatement s2)
{
// set skip metadata only when result metadata id is supported because of CASSANDRA-10786
var skipMetadata =
serializer.ProtocolVersion.SupportsResultMetadataId() &&
s2.PreparedStatement.ResultMetadata.ContainsColumnDefinitions();
var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s2, requestOptions, skipMetadata);
request = new ExecuteRequest(
serializer,
s2.PreparedStatement.Id,
null,
s2.PreparedStatement.ResultMetadata,
options,
s2.IsTracing,
s2.OutgoingPayload);
}
if (statement is BatchStatement s)
{
s.Serializer = serializer;
var consistency = requestOptions.ConsistencyLevel;
if (s.ConsistencyLevel.HasValue)
{
consistency = s.ConsistencyLevel.Value;
}
request = new BatchRequest(serializer, s.OutgoingPayload, s, consistency, requestOptions);
}
if (request == null)
{
throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported");
}
return(request);
}
public async Task <Response> SendMetadataRequestAsync(
IConnection connection, ProtocolVersion version, string cqlQuery, QueryProtocolOptions queryProtocolOptions)
{
var request = new QueryRequest(version, cqlQuery, false, queryProtocolOptions);
Response response;
try
{
response = await connection.Send(request).ConfigureAwait(false);
}
catch (SocketException ex)
{
ControlConnection.Logger.Error(
$"There was an error while executing on the host {cqlQuery} the query '{connection.EndPoint.EndpointFriendlyName}'", ex);
throw;
}
return(response);
}
private async Task <Response> Send(
IConnection connection, ISerializer serializer, string cqlQuery, QueryProtocolOptions queryProtocolOptions)
{
Requests.Enqueue(new MetadataRequest
{
Serializer = serializer,
CqlQuery = cqlQuery,
QueryProtocolOptions = queryProtocolOptions
});
await Task.Yield();
ThrowErrorIfNullRows(cqlQuery);
var response = new FakeResultResponse(ResultResponse.ResultResponseKind.Rows);
_responsesByCql.AddOrUpdate(response, _ => cqlQuery, (_, __) => cqlQuery);
return((Response)response);
}
/// <summary>
/// Gets the Request to send to a cassandra node based on the statement type
/// </summary>
internal static IRequest GetRequest(IStatement statement, Serializer serializer, Configuration config)
{
ICqlRequest request = null;
if (statement.IsIdempotent == null)
{
statement.SetIdempotence(config.QueryOptions.GetDefaultIdempotence());
}
if (statement is RegularStatement)
{
var s = (RegularStatement)statement;
s.Serializer = serializer;
var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s, config.QueryOptions, config.Policies);
options.ValueNames = s.QueryValueNames;
request = new QueryRequest(serializer.ProtocolVersion, s.QueryString, s.IsTracing, options);
}
if (statement is BoundStatement)
{
var s = (BoundStatement)statement;
var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s, config.QueryOptions, config.Policies);
request = new ExecuteRequest(serializer.ProtocolVersion, s.PreparedStatement.Id, null, s.IsTracing, options);
}
if (statement is BatchStatement)
{
var s = (BatchStatement)statement;
s.Serializer = serializer;
var consistency = config.QueryOptions.GetConsistencyLevel();
if (s.ConsistencyLevel != null)
{
consistency = s.ConsistencyLevel.Value;
}
request = new BatchRequest(serializer.ProtocolVersion, s, consistency);
}
if (request == null)
{
throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported");
}
//Set the outgoing payload for the request
request.Payload = statement.OutgoingPayload;
return(request);
}
public void ExecutePreparedWithParamTest()
{
using (var connection = CreateConnection())
{
connection.Init();
var prepareRequest = new PrepareRequest(connection.ProtocolVersion, "SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ?");
var task = connection.Send(prepareRequest);
var prepareOutput = ValidateResult <OutputPrepared>(task.Result);
var options = new QueryProtocolOptions(ConsistencyLevel.One, new[] { "system" }, false, 100, null, ConsistencyLevel.Any);
var executeRequest = new ExecuteRequest(connection.ProtocolVersion, prepareOutput.QueryId, null, false, options);
task = connection.Send(executeRequest);
var output = ValidateResult <OutputRows>(task.Result);
var rows = output.RowSet.ToList();
Assert.Greater(rows.Count, 0);
Assert.True(rows[0].GetValue <string>("columnfamily_name") != null, "It should contain a column family name");
}
}
/// <summary>
/// Gets the Request to send to a cassandra node based on the statement type
/// </summary>
internal static IRequest GetRequest(IStatement statement, ISerializer serializer, IRequestOptions requestOptions)
{
ICqlRequest request = null;
if (statement.IsIdempotent == null)
{
statement.SetIdempotence(requestOptions.DefaultIdempotence);
}
if (statement is RegularStatement s1)
{
s1.Serializer = serializer;
var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s1, requestOptions);
options.ValueNames = s1.QueryValueNames;
request = new QueryRequest(serializer.ProtocolVersion, s1.QueryString, s1.IsTracing, options);
}
if (statement is BoundStatement s2)
{
var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s2, requestOptions);
request = new ExecuteRequest(serializer.ProtocolVersion, s2.PreparedStatement.Id, null,
s2.PreparedStatement.ResultMetadataId, s2.IsTracing, options);
}
if (statement is BatchStatement s)
{
s.Serializer = serializer;
var consistency = requestOptions.ConsistencyLevel;
if (s.ConsistencyLevel.HasValue)
{
consistency = s.ConsistencyLevel.Value;
}
request = new BatchRequest(serializer.ProtocolVersion, s, consistency, requestOptions);
}
if (request == null)
{
throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported");
}
//Set the outgoing payload for the request
request.Payload = statement.OutgoingPayload;
return(request);
}
private Task <Response> Query(Connection connection, string query, QueryProtocolOptions options = null)
{
var request = GetQueryRequest(query, options);
return(connection.Send(request));
}
private Task <Response> Send(IConnection connection, ProtocolVersion version, string cqlQuery, QueryProtocolOptions queryProtocolOptions)
{
Requests.Enqueue(new MetadataRequest {
Version = version, CqlQuery = cqlQuery, QueryProtocolOptions = queryProtocolOptions
});
var response = new FakeResultResponse(ResultResponse.ResultResponseKind.Rows);
_responsesByCql.AddOrUpdate(response, _ => cqlQuery, (_, __) => cqlQuery);
return(Task.FromResult((Response)response));
}
public Task <Response> UnsafeSendQueryRequestAsync(
IConnection connection, ProtocolVersion version, string cqlQuery, QueryProtocolOptions queryProtocolOptions)
{
return(connection.Send(new QueryRequest(version, cqlQuery, false, queryProtocolOptions)));
}
override public void Begin(Session owner, int streamId)
{
Connection.BeginExecuteQuery(streamId, Id, CqlQuery, Metadata, owner.RequestCallback, this, owner, IsTracing, QueryProtocolOptions.CreateFromQuery(Statement, owner.Cluster.Configuration.QueryOptions.GetConsistencyLevel()), Consistency);
}
public Task <Response> SendMetadataRequestAsync(IConnection connection, ProtocolVersion version, string cqlQuery, QueryProtocolOptions queryProtocolOptions)
{
return(Send(connection, version, cqlQuery, queryProtocolOptions));
}
public Task <Response> UnsafeSendQueryRequestAsync(
IConnection connection, ISerializer serializer, string cqlQuery, QueryProtocolOptions queryProtocolOptions)
{
return(connection.Send(new QueryRequest(serializer, cqlQuery, queryProtocolOptions, false, null)));
}
public Task <Response> UnsafeSendQueryRequestAsync(
IConnection connection, ISerializer serializer, string cqlQuery, QueryProtocolOptions queryProtocolOptions)
{
return(Send(connection, serializer, cqlQuery, queryProtocolOptions));
}
protected RegularStatement(QueryProtocolOptions queryProtocolOptions) : base(queryProtocolOptions)
{
}
