internal static QueryProtocolOptions CreateFromQuery(
ProtocolVersion protocolVersion, Statement query, IRequestOptions requestOptions)
{
if (query == null)
{
return(Default);
}
var consistency = query.ConsistencyLevel ?? requestOptions.ConsistencyLevel;
var pageSize = query.PageSize != 0 ? query.PageSize : requestOptions.PageSize;
long?timestamp = null;
if (query.Timestamp != null)
{
timestamp = TypeSerializer.SinceUnixEpoch(query.Timestamp.Value).Ticks / 10;
}
else if (protocolVersion.SupportsTimestamp())
{
timestamp = requestOptions.TimestampGenerator.Next();
if (timestamp == long.MinValue)
{
timestamp = null;
}
}
return(new QueryProtocolOptions(
consistency,
query.QueryValues,
query.SkipMetadata,
pageSize,
query.PagingState,
requestOptions.GetSerialConsistencyLevelOrDefault(query),
timestamp,
query.Keyspace));
}
public void GetRequest_With_Timestamp_Generator()
{
// Timestamp generator should be enabled by default
var statement = new SimpleStatement("QUERY");
var config = new Configuration();
var request = RequestHandler.GetRequest(statement, Serializer, config);
var bodyBuffer = GetBodyBuffer(request);
// The query request is composed by:
// <query><consistency><flags><result_page_size><paging_state><serial_consistency><timestamp>
var queryBuffer = BeConverter.GetBytes(statement.QueryString.Length)
.Concat(Encoding.UTF8.GetBytes(statement.QueryString))
.ToArray();
CollectionAssert.AreEqual(queryBuffer, bodyBuffer.Take(queryBuffer.Length));
// Skip the query and consistency (2)
var offset = queryBuffer.Length + 2;
var flags = GetQueryFlags(bodyBuffer, ref offset);
Assert.True(flags.HasFlag(QueryFlags.WithDefaultTimestamp));
Assert.True(flags.HasFlag(QueryFlags.PageSize));
Assert.False(flags.HasFlag(QueryFlags.Values));
Assert.False(flags.HasFlag(QueryFlags.WithPagingState));
Assert.False(flags.HasFlag(QueryFlags.SkipMetadata));
Assert.True(flags.HasFlag(QueryFlags.WithSerialConsistency));
// Skip result_page_size (4) + serial_consistency (2)
offset += 6;
var timestamp = BeConverter.ToInt64(bodyBuffer, offset);
var expectedTimestamp = TypeSerializer.SinceUnixEpoch(DateTimeOffset.Now.Subtract(TimeSpan.FromMilliseconds(100))).Ticks / 10;
Assert.Greater(timestamp, expectedTimestamp);
}
public void CqlClient_Timestamp()
{
var config = new MappingConfiguration()
.Define(new Map <Song>().PartitionKey(s => s.Id).TableName("song_insert"));
//Use linq to create the table
var table = new Table <Song>(_session, config);
table.CreateIfNotExists();
var mapper = new Mapper(_session, config);
var song = new Song
{
Id = Guid.NewGuid(),
Artist = "The Who",
Title = "Substitute",
ReleaseDate = DateTimeOffset.UtcNow
};
//Set timestamp to 1 day ago
var timestamp = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(1));
mapper.Insert(song, true, CqlQueryOptions.New().SetTimestamp(timestamp));
//query for timestamp in a column of the record
var cqlLowerCasePartitionKey = "SELECT WRITETIME (Artist) AS timestamp FROM " + table.Name + " WHERE Id = " + song.Id + ";";
var rows = _session.Execute(cqlLowerCasePartitionKey).GetRows().ToList();
Assert.AreEqual(1, rows.Count);
var creationTimestamp = rows[0].GetValue <long>("timestamp");
Assert.NotNull(creationTimestamp);
//Timestamp retrieved is in macroseconds. Converting it to milliseconds
Assert.AreEqual(TypeSerializer.SinceUnixEpoch(timestamp).Ticks / 10, rows[0].GetValue <object>("timestamp"));
}
internal static QueryProtocolOptions CreateFromQuery(ProtocolVersion protocolVersion, Statement query,
QueryOptions queryOptions, Policies policies)
{
if (query == null)
{
return(Default);
}
var consistency = query.ConsistencyLevel ?? queryOptions.GetConsistencyLevel();
var pageSize = query.PageSize != 0 ? query.PageSize : queryOptions.GetPageSize();
long?timestamp = null;
if (query.Timestamp != null)
{
timestamp = TypeSerializer.SinceUnixEpoch(query.Timestamp.Value).Ticks / 10;
}
else if (protocolVersion.SupportsTimestamp())
{
timestamp = policies.TimestampGenerator.Next();
if (timestamp == long.MinValue)
{
timestamp = null;
}
}
return(new QueryProtocolOptions(
consistency,
query.QueryValues,
query.SkipMetadata,
pageSize,
query.PagingState,
query.SerialConsistencyLevel,
timestamp));
}
public void GetRequest_With_Timestamp_Generator_Empty_Value_With_Statement_Timestamp()
{
var statement = new SimpleStatement("STATEMENT WITH TIMESTAMP");
var expectedTimestamp = new DateTimeOffset(2010, 04, 29, 1, 2, 3, 4, TimeSpan.Zero).AddTicks(20);
statement.SetTimestamp(expectedTimestamp);
var policies = new Cassandra.Policies(
Cassandra.Policies.DefaultLoadBalancingPolicy, Cassandra.Policies.DefaultReconnectionPolicy,
Cassandra.Policies.DefaultRetryPolicy, Cassandra.Policies.DefaultSpeculativeExecutionPolicy,
new NoTimestampGenerator());
var config = RequestHandlerTests.GetConfig(new QueryOptions(), policies, PoolingOptions.Create());
var request = RequestHandler.GetRequest(statement, Serializer, config.DefaultRequestOptions);
var bodyBuffer = GetBodyBuffer(request);
// The query request is composed by:
// <query><consistency><flags><result_page_size><paging_state><serial_consistency><timestamp>
var queryBuffer = BeConverter.GetBytes(statement.QueryString.Length)
.Concat(Encoding.UTF8.GetBytes(statement.QueryString))
.ToArray();
CollectionAssert.AreEqual(queryBuffer, bodyBuffer.Take(queryBuffer.Length));
// Skip the query and consistency (2)
var offset = queryBuffer.Length + 2;
var flags = GetQueryFlags(bodyBuffer, ref offset);
Assert.True(flags.HasFlag(QueryFlags.WithDefaultTimestamp));
Assert.True(flags.HasFlag(QueryFlags.PageSize));
// Skip result_page_size (4) + serial_consistency (2)
offset += 6;
var timestamp = BeConverter.ToInt64(bodyBuffer, offset);
Assert.AreEqual(TypeSerializer.SinceUnixEpoch(expectedTimestamp).Ticks / 10, timestamp);
}
//TODO: Move to ExecuteRequest and QueryRequest
internal void Write(FrameWriter wb, bool isPrepared)
{
//protocol v1: <query><n><value_1>....<value_n><consistency>
//protocol v2: <query><consistency><flags>[<n><value_1>...<value_n>][<result_page_size>][<paging_state>][<serial_consistency>]
//protocol v3: <query><consistency><flags>[<n>[name_1]<value_1>...[name_n]<value_n>][<result_page_size>][<paging_state>][<serial_consistency>][<timestamp>]
var protocolVersion = wb.Serializer.ProtocolVersion;
var flags = GetFlags();
if (protocolVersion > 1)
{
wb.WriteUInt16((ushort)Consistency);
wb.WriteByte((byte)flags);
}
if (flags.HasFlag(QueryFlags.Values))
{
wb.WriteUInt16((ushort)Values.Length);
for (var i = 0; i < Values.Length; i++)
{
if (flags.HasFlag(QueryFlags.WithNameForValues))
{
var name = ValueNames[i];
wb.WriteString(name);
}
wb.WriteAsBytes(Values[i]);
}
}
else if (protocolVersion == 1 && isPrepared)
{
//n values is not optional on protocol v1
//Write 0 values
wb.WriteUInt16(0);
}
if (protocolVersion == 1)
{
//Protocol v1 ends here
wb.WriteUInt16((ushort)Consistency);
return;
}
if ((flags & QueryFlags.PageSize) == QueryFlags.PageSize)
{
wb.WriteInt32(PageSize);
}
if ((flags & QueryFlags.WithPagingState) == QueryFlags.WithPagingState)
{
wb.WriteBytes(PagingState);
}
if ((flags & QueryFlags.WithSerialConsistency) == QueryFlags.WithSerialConsistency)
{
wb.WriteUInt16((ushort)SerialConsistency);
}
if (Timestamp != null)
{
//Expressed in microseconds
wb.WriteLong(TypeSerializer.SinceUnixEpoch(Timestamp.Value).Ticks / 10);
}
}
/// <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 SimpleStatementSetTimestamp()
{
var timestamp = new DateTimeOffset(1999, 12, 31, 1, 2, 3, TimeSpan.Zero);
var id = Guid.NewGuid();
var insertStatement = new SimpleStatement(string.Format("INSERT INTO {0} (id, text_sample) VALUES (?, ?)", AllTypesTableName), id, "sample text");
Session.Execute(insertStatement.SetTimestamp(timestamp));
var row = Session.Execute(new SimpleStatement(string.Format("SELECT id, text_sample, writetime(text_sample) FROM {0} WHERE id = ?", AllTypesTableName), id)).First();
Assert.NotNull(row.GetValue <string>("text_sample"));
Assert.AreEqual(TypeSerializer.SinceUnixEpoch(timestamp).Ticks / 10, row.GetValue <object>("writetime(text_sample)"));
}
public void GetRequest_With_Timestamp_Generator_Empty_Value_With_Statement_Timestamp()
{
var statement = new SimpleStatement("STATEMENT WITH TIMESTAMP");
var expectedTimestamp = new DateTimeOffset(2010, 04, 29, 1, 2, 3, 4, TimeSpan.Zero).AddTicks(20);
statement.SetTimestamp(expectedTimestamp);
var policies = new Policies(
Policies.DefaultLoadBalancingPolicy, Policies.DefaultReconnectionPolicy, Policies.DefaultRetryPolicy,
Policies.DefaultSpeculativeExecutionPolicy, new NoTimestampGenerator());
var config = new Configuration(
policies,
new ProtocolOptions(),
PoolingOptions.Create(),
new SocketOptions(),
new ClientOptions(),
NoneAuthProvider.Instance,
null,
new QueryOptions(),
new DefaultAddressTranslator(),
Mock.Of <IStartupOptionsFactory>(),
new SessionFactoryBuilder());
var request = RequestHandler.GetRequest(statement, Serializer, config);
var bodyBuffer = GetBodyBuffer(request);
// The query request is composed by:
// <query><consistency><flags><result_page_size><paging_state><serial_consistency><timestamp>
var queryBuffer = BeConverter.GetBytes(statement.QueryString.Length)
.Concat(Encoding.UTF8.GetBytes(statement.QueryString))
.ToArray();
CollectionAssert.AreEqual(queryBuffer, bodyBuffer.Take(queryBuffer.Length));
// Skip the query and consistency (2)
var offset = queryBuffer.Length + 2;
// The remaining length should be = flags (1) + result_page_size (4) + serial_consistency (2) + timestamp (8)
Assert.AreEqual(15, bodyBuffer.Length - offset);
var flags = GetQueryFlags(bodyBuffer, ref offset);
Assert.True(flags.HasFlag(QueryFlags.WithDefaultTimestamp));
Assert.True(flags.HasFlag(QueryFlags.PageSize));
// Skip result_page_size (4) + serial_consistency (2)
offset += 6;
var timestamp = BeConverter.ToInt64(bodyBuffer, offset);
Assert.AreEqual(TypeSerializer.SinceUnixEpoch(expectedTimestamp).Ticks / 10, timestamp);
}
public void GetRequest_With_Timestamp_Generator_Empty_Value_With_Statement_Timestamp()
{
var statement = new SimpleStatement("STATEMENT WITH TIMESTAMP");
var expectedTimestamp = new DateTimeOffset(2010, 04, 29, 1, 2, 3, 4, TimeSpan.Zero).AddTicks(20);
statement.SetTimestamp(expectedTimestamp);
var policies = new Dse.Policies(
Dse.Policies.DefaultLoadBalancingPolicy, Dse.Policies.DefaultReconnectionPolicy,
Dse.Policies.DefaultRetryPolicy, Dse.Policies.DefaultSpeculativeExecutionPolicy,
new NoTimestampGenerator());
var config = new Configuration(
policies, new ProtocolOptions(), PoolingOptions.GetDefault(ProtocolVersion.MaxSupported), new SocketOptions(), new ClientOptions(),
NoneAuthProvider.Instance, null, new QueryOptions(), new DefaultAddressTranslator());
var request = RequestHandler <RowSet> .GetRequest(statement, Serializer, config);
var stream = new MemoryStream();
request.WriteFrame(1, stream, Serializer);
var headerSize = FrameHeader.GetSize(ProtocolVersion.MaxSupported);
var bodyBuffer = new byte[stream.Length - headerSize];
stream.Position = headerSize;
stream.Read(bodyBuffer, 0, bodyBuffer.Length);
// The query request is composed by:
// <query><consistency><flags><result_page_size><timestamp>
var queryBuffer = BeConverter.GetBytes(statement.QueryString.Length)
.Concat(Encoding.UTF8.GetBytes(statement.QueryString))
.ToArray();
CollectionAssert.AreEqual(queryBuffer, bodyBuffer.Take(queryBuffer.Length));
// Skip the query and consistency (2)
var offset = queryBuffer.Length + 2;
// The remaining length should be 13 = flags (1) + result_page_size (4) + timestamp (8)
Assert.AreEqual(13, bodyBuffer.Length - offset);
var flags = (QueryFlags)bodyBuffer[offset];
Assert.True(flags.HasFlag(QueryFlags.WithDefaultTimestamp));
Assert.True(flags.HasFlag(QueryFlags.PageSize));
// Skip flags (1) + result_page_size (4)
offset += 5;
var timestamp = BeConverter.ToInt64(bodyBuffer, offset);
Assert.AreEqual(TypeSerializer.SinceUnixEpoch(expectedTimestamp).Ticks / 10, timestamp);
}
/// <summary>
/// Gets the timestamp of the request or null if not defined.
/// </summary>
/// <exception cref="NotSupportedException" />
private static long?GetRequestTimestamp(ProtocolVersion protocolVersion, BatchStatement statement, ITimestampGenerator timestampGenerator)
{
if (!protocolVersion.SupportsTimestamp())
{
if (statement.Timestamp != null)
{
throw new NotSupportedException(
"Timestamp for BATCH request is supported in Cassandra 2.1 or above.");
}
return(null);
}
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 GetRequest_With_Timestamp_Generator()
{
// Timestamp generator should be enabled by default
var statement = new SimpleStatement("QUERY");
var config = new Configuration();
var request = RequestHandler <RowSet> .GetRequest(statement, Serializer, config);
var stream = new MemoryStream();
request.WriteFrame(1, stream, Serializer);
var headerSize = FrameHeader.GetSize(ProtocolVersion.MaxSupported);
var bodyBuffer = new byte[stream.Length - headerSize];
stream.Position = headerSize;
stream.Read(bodyBuffer, 0, bodyBuffer.Length);
// The query request is composed by:
// <query><consistency><flags><result_page_size><timestamp>
var queryBuffer = BeConverter.GetBytes(statement.QueryString.Length)
.Concat(Encoding.UTF8.GetBytes(statement.QueryString))
.ToArray();
CollectionAssert.AreEqual(queryBuffer, bodyBuffer.Take(queryBuffer.Length));
// Skip the query and consistency (2)
var offset = queryBuffer.Length + 2;
// The remaining length should be 13 = flags (1) + result_page_size (4) + timestamp (8)
Assert.AreEqual(13, bodyBuffer.Length - offset);
var flags = (QueryFlags)bodyBuffer[offset];
Assert.True(flags.HasFlag(QueryFlags.WithDefaultTimestamp));
Assert.True(flags.HasFlag(QueryFlags.PageSize));
Assert.False(flags.HasFlag(QueryFlags.Values));
Assert.False(flags.HasFlag(QueryFlags.WithPagingState));
Assert.False(flags.HasFlag(QueryFlags.SkipMetadata));
Assert.False(flags.HasFlag(QueryFlags.WithSerialConsistency));
// Skip flags (1) + result_page_size (4)
offset += 5;
var timestamp = BeConverter.ToInt64(bodyBuffer, offset);
var expectedTimestamp = TypeSerializer.SinceUnixEpoch(DateTimeOffset.Now.Subtract(TimeSpan.FromMilliseconds(100))).Ticks / 10;
Assert.Greater(timestamp, expectedTimestamp);
}
public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
//protocol v2: <type><n><query_1>...<query_n><consistency>
//protocol v3: <type><n><query_1>...<query_n><consistency><flags>[<serial_consistency>][<timestamp>]
var protocolVersion = serializer.ProtocolVersion;
var wb = new FrameWriter(stream, serializer);
if (Payload != null)
{
_headerFlags |= FrameHeader.HeaderFlag.CustomPayload;
}
wb.WriteFrameHeader((byte)_headerFlags, streamId, OpCode);
if (Payload != null)
{
//A custom payload for this request
wb.WriteBytesMap(Payload);
}
wb.WriteByte((byte)_type);
wb.WriteInt16((short)_requests.Count);
foreach (var br in _requests)
{
br.WriteToBatch(wb);
}
wb.WriteInt16((short)Consistency);
if (protocolVersion >= 3)
{
wb.WriteByte((byte)_batchFlags);
}
if (_serialConsistency != null)
{
wb.WriteInt16((short)_serialConsistency.Value);
}
if (_timestamp != null)
{
//Expressed in microseconds
wb.WriteLong(TypeSerializer.SinceUnixEpoch(_timestamp.Value).Ticks / 10);
}
return(wb.Close());
}