public async Task ReadExact()
{
using (var connection = _fixture.GetConnection())
{
await connection.OpenAsync();
var targetReadTimestamp = _fixture.TimestampBeforeEntries;
using (var tx =
await connection.BeginReadOnlyTransactionAsync(
TimestampBound.OfReadTimestamp(targetReadTimestamp)))
{
Assert.Equal(TransactionMode.ReadOnly, tx.Mode);
Assert.Equal(targetReadTimestamp, tx.TimestampBound.Timestamp);
var cmd = CreateSelectAllCommandForKey(connection);
cmd.Transaction = tx;
using (var reader = await cmd.ExecuteReaderAsync())
{
Assert.False(
await reader.ReadAsync(),
"no data should be here from yesterday!");
}
}
}
}
public async Task ReadExact()
{
await WriteSampleRowsAsync();
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
await connection.OpenAsync();
var targetReadTimestamp = _history[0].Timestamp.AddMinutes(-1);
using (var tx =
await connection.BeginReadOnlyTransactionAsync(
TimestampBound.OfReadTimestamp(targetReadTimestamp)))
{
Assert.Equal(TransactionMode.ReadOnly, tx.Mode);
Assert.Equal(targetReadTimestamp, tx.TimestampBound.Timestamp);
var cmd = connection.CreateSelectCommand(
"SELECT * FROM TX WHERE K=@k",
new SpannerParameterCollection {
{ "k", _key, SpannerDbType.String }
});
cmd.Transaction = tx;
using (var reader = await cmd.ExecuteReaderAsync())
{
Assert.False(
await reader.ReadAsync(),
"no data should be here from yesterday!");
}
}
}
}
public void Equality()
{
DateTime timestamp1 = new DateTime(2000, 6, 1, 23, 1, 5, DateTimeKind.Utc);
TimeSpan staleness1 = TimeSpan.FromSeconds(10);
DateTime timestamp2 = new DateTime(2005, 1, 1, 1, 1, 1, DateTimeKind.Utc);
TimeSpan staleness2 = TimeSpan.FromSeconds(30);
var strong = TimestampBound.Strong;
var minRead = TimestampBound.OfMinReadTimestamp(timestamp1);
var read = TimestampBound.OfReadTimestamp(timestamp1);
var exactStaleness = TimestampBound.OfExactStaleness(staleness1);
var maxStaleness = TimestampBound.OfMaxStaleness(staleness1);
EqualityTester.AssertEqual(strong,
new[] { strong },
new[] { minRead, read, exactStaleness, maxStaleness });
EqualityTester.AssertEqual(minRead,
new[] { TimestampBound.OfMinReadTimestamp(timestamp1) },
new[] { strong, read, exactStaleness, maxStaleness, TimestampBound.OfMinReadTimestamp(timestamp2) });
EqualityTester.AssertEqual(read,
new[] { TimestampBound.OfReadTimestamp(timestamp1) },
new[] { strong, minRead, exactStaleness, maxStaleness, TimestampBound.OfReadTimestamp(timestamp2) });
EqualityTester.AssertEqual(exactStaleness,
new[] { TimestampBound.OfExactStaleness(staleness1) },
new[] { strong, minRead, read, maxStaleness, TimestampBound.OfExactStaleness(staleness2) });
EqualityTester.AssertEqual(maxStaleness,
new[] { TimestampBound.OfMaxStaleness(staleness1) },
new[] { strong, minRead, read, exactStaleness, TimestampBound.OfMaxStaleness(staleness2) });
}
public void Timestamp_UtcIsValid()
{
var timestamp = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
TimestampBound.OfMinReadTimestamp(timestamp);
TimestampBound.OfReadTimestamp(timestamp);
}
public void Timestamp_NonUtcIsInvalid(DateTimeKind kind)
{
var timestamp = new DateTime(2000, 1, 1, 0, 0, 0, kind);
Assert.Throws <ArgumentException>(() => TimestampBound.OfMinReadTimestamp(timestamp));
Assert.Throws <ArgumentException>(() => TimestampBound.OfReadTimestamp(timestamp));
}
public async Task ExactReadMultiUseWithReturnReadTimestamp()
{
using (var connection = _fixture.GetConnection())
{
await connection.OpenAsync();
var targetReadTimestamp = _fixture.TimestampBeforeEntries;
var bound = TimestampBound.OfReadTimestamp(targetReadTimestamp).WithReturnReadTimestamp(true);
using (var tx = await connection.BeginReadOnlyTransactionAsync(bound))
{
Assert.Equal(TransactionMode.ReadOnly, tx.Mode);
Assert.Equal(targetReadTimestamp, tx.TimestampBound.Timestamp);
Assert.True(tx.TimestampBound.ReturnReadTimestamp);
var cmd = CreateSelectAllCommandForKey(connection);
cmd.Transaction = tx;
using (var reader = await cmd.ExecuteReaderAsync())
{
Assert.Equal(wkt::Timestamp.FromDateTime(targetReadTimestamp), reader.GetReadTimestamp());
Assert.False(
await reader.ReadAsync(),
"no data should be here from yesterday!");
}
}
}
}
public void ToTransactionOptions_OfExactTimestamp()
{
var bound = TimestampBound.OfReadTimestamp(new DateTime(1970, 1, 1, 0, 0, 10, DateTimeKind.Utc));
AssertProtoConversion(new ReadOnly {
ReadTimestamp = new Timestamp {
Seconds = 10
}
}, bound);
}
public void ToTransactionOptions_WithReturnReadTimestamp()
{
var bound = TimestampBound.OfReadTimestamp(new DateTime(1970, 1, 1, 0, 0, 10, DateTimeKind.Utc)).WithReturnReadTimestamp(true);
AssertProtoConversion(new ReadOnly {
ReadTimestamp = new Timestamp {
Seconds = 10
}, ReturnReadTimestamp = true
}, bound);
}
public async Task ReadExactSingle()
{
using (var connection = _fixture.GetConnection())
{
await connection.OpenAsync();
var cmd = CreateSelectAllCommandForKey(connection);
using (var reader = await cmd.ExecuteReaderAsync(TimestampBound.OfReadTimestamp(_oldestEntry.Timestamp)))
{
if (await reader.ReadAsync())
{
Assert.Equal(_oldestEntry.Value, reader.GetFieldValue <string>(reader.GetOrdinal("StringValue")));
}
}
}
}
public async Task ExactReadSinglueUseWithReturnReadTimestamp()
{
using (var connection = _fixture.GetConnection())
{
await connection.OpenAsync();
var cmd = CreateSelectAllCommandForKey(connection);
var bound = TimestampBound.OfReadTimestamp(_oldestEntry.Timestamp).WithReturnReadTimestamp(true);
using (var reader = (SpannerDataReader)(await cmd.ExecuteReaderAsync(bound)))
{
Assert.Equal(wkt::Timestamp.FromDateTime(_oldestEntry.Timestamp), reader.GetReadTimestamp());
if (await reader.ReadAsync())
{
Assert.Equal(_oldestEntry.Value, reader.GetFieldValue <string>(reader.GetOrdinal("StringValue")));
}
}
}
}
public async Task ReadExactSingle()
{
await WriteSampleRowsAsync();
await Task.Delay(6);
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
await connection.OpenAsync();
var cmd = connection.CreateSelectCommand(
"SELECT * FROM TX WHERE K=@k",
new SpannerParameterCollection {
{ "k", _key, SpannerDbType.String }
});
using (var reader = await cmd.ExecuteReaderAsync(TimestampBound.OfReadTimestamp(_history[0].Timestamp)))
{
if (await reader.ReadAsync())
{
Assert.Equal(_history[0].Value, reader.GetFieldValue <string>(reader.GetOrdinal("StringValue")));
}
}
}
}
