public async Task AdapterFill()
{
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
var adapter = new SpannerDataAdapter(connection, _testFixture.DataAdapterTestTable, "Key");
var testDataSet = new DataSet();
adapter.Fill(testDataSet);
Assert.Equal(1, testDataSet.Tables.Count);
Assert.Equal(2, testDataSet.Tables[0].Columns.Count);
Assert.Equal(_testFixture.TestTableRowCount, testDataSet.Tables[0].Rows.Count);
}
}
public async Task DistributedReadAsync()
{
int numRows;
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
using (var cmd = connection.CreateSelectCommand("SELECT COUNT(*) FROM Orders"))
{
numRows = await cmd.ExecuteScalarAsync <int>();
}
using (var connection = new SpannerConnection(_testFixture.ConnectionString))
{
await connection.OpenAsync();
using (var transaction = await connection.BeginReadOnlyTransactionAsync())
using (var cmd = connection.CreateSelectCommand("SELECT * FROM Orders"))
{
transaction.DisposeBehavior = DisposeBehavior.CloseResources;
cmd.Transaction = transaction;
var partitions = await cmd.GetReaderPartitionsAsync(1000);
var transactionId = transaction.TransactionId;
//we simulate a serialization/deserialization step in the call to the subtask.
await Task.WhenAll(partitions.Select(
x => DistributedReadWorkerAsync(CommandPartition.FromBase64String(x.ToBase64String()),
TransactionId.FromBase64String(transactionId.ToBase64String()))))
.ConfigureAwait(false);
}
Assert.Equal(numRows, _rowsRead);
}
}
public async Task TestChunking()
{
Logger.Instance.Info($"Seed={_seed}");
var rowsRead = 0;
int rowsToWrite = _random.Next(1, 6);
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
await connection.OpenAsync();
using (var tx = await connection.BeginTransactionAsync())
{
using (var cmd = connection.CreateInsertCommand(
_testFixture.ChunkingTestTable, new SpannerParameterCollection
{
new SpannerParameter("K", SpannerDbType.String),
new SpannerParameter("StringValue", SpannerDbType.String),
new SpannerParameter("StringArrayValue", SpannerDbType.ArrayOf(SpannerDbType.String)),
new SpannerParameter("BytesValue", SpannerDbType.Bytes),
new SpannerParameter("BytesArrayValue", SpannerDbType.ArrayOf(SpannerDbType.Bytes))
}))
{
cmd.Transaction = tx;
//write 1-5 rows
for (var i = 0; i < rowsToWrite; i++)
{
await InsertRowAsync(cmd);
}
await tx.CommitAsync();
}
}
using (var readCmd = connection.CreateSelectCommand($"SELECT * FROM {_testFixture.ChunkingTestTable}"))
{
using (var reader = (SpannerDataReader)await readCmd.ExecuteReaderAsync())
{
var keySet = new HashSet <string>();
while (await reader.ReadAsync())
{
var k = reader.GetFieldValue <string>("K");
if (!_addedKeys.Contains(k))
{
continue; // this key is from a previous test run.
}
rowsRead++;
Assert.True(keySet.Add(k));
Assert.Equal(_stringValues[k], reader.GetFieldValue <string>("StringValue"));
Assert.Equal(_stringArrayValues[k], reader.GetFieldValue <string[]>("StringArrayValue"));
Assert.Equal(_bytesValues[k], reader.GetFieldValue <byte[]>("BytesValue"));
Assert.Equal(_bytesArrayValues[k], reader.GetFieldValue <byte[][]>("BytesArrayValue"));
}
}
}
}
Assert.Equal(rowsToWrite, rowsRead);
}
private async Task <TimeSpan> TestWriteOneRow(Stopwatch sw)
{
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
var localCounter = Interlocked.Increment(ref s_rowCounter);
var insertCommand = connection.CreateInsertCommand(
_testFixture.StressTestTable, new SpannerParameterCollection
{
{ "ID", SpannerDbType.String },
{ "Title", SpannerDbType.String }
});
insertCommand.Parameters["ID"].Value = $"{s_guid}{localCounter}";
insertCommand.Parameters["Title"].Value = "Title";
// This uses an ephemeral transaction, so its legal to retry it.
await ExecuteWithRetry(insertCommand.ExecuteNonQueryAsync);
}
return(sw.Elapsed);
}
private async Task TestBind <T>(SpannerDbType parameterType, T value, Func <SpannerDataReader, T> typeSpecificReader = null)
{
int rowsRead;
var valueRead = default(T);
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
var cmd = connection.CreateSelectCommand(
"SELECT @v",
new SpannerParameterCollection {
new SpannerParameter("v", parameterType)
});
cmd.Parameters["v"].Value = value;
using (var reader = await cmd.ExecuteReaderAsync())
{
rowsRead = 0;
while (await reader.ReadAsync())
{
valueRead = reader.GetFieldValue <T>(0);
// optional extra test for certain built in types
if (typeSpecificReader != null)
{
Assert.Equal(typeSpecificReader(reader), valueRead);
// ReSharper disable once CompareNonConstrainedGenericWithNull
Assert.Equal(reader.IsDBNull(0), value == null);
}
rowsRead++;
}
}
}
Assert.Equal(1, rowsRead);
var valueAsArray = value as Array;
if (valueAsArray != null)
{
var valueReadAsArray = valueRead as Array;
Assert.NotNull(valueReadAsArray);
Assert.Equal(valueAsArray.Length, valueReadAsArray.Length);
for (int i = 0; i < valueAsArray.Length; i++)
{
// ReSharper disable once PossibleNullReferenceException
Assert.Equal(valueAsArray.GetValue(i), valueReadAsArray.GetValue(i));
}
}
else
{
Assert.Equal(value, valueRead);
}
}
public async Task BindNull(SpannerDbType parameterType)
{
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
var cmd = connection.CreateSelectCommand(
"SELECT @v",
new SpannerParameterCollection {
new SpannerParameter("v", parameterType)
});
cmd.Parameters["v"].Value = null;
using (var reader = await cmd.ExecuteReaderAsync())
{
Assert.True(await reader.ReadAsync());
Assert.True(reader.IsDBNull(0));
Assert.Equal(DBNull.Value, reader.GetValue(0));
Assert.False(await reader.ReadAsync());
}
}
}
private async Task <int> InsertAsync(SpannerParameterCollection values)
{
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
values.Add("K", SpannerDbType.String, _lastKey = UniqueString());
var cmd = connection.CreateInsertCommand("T", values);
return(await cmd.ExecuteNonQueryAsync());
}
}
private async Task WriteSampleRowsAsync()
{
await _testFixture.EnsureTestDatabaseAsync();
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
await WriteSampleRowsAsync(connection);
}
}
private async Task WriteSampleRowsAsync()
{
await _testFixture.EnsureTestDatabaseAsync();
if (string.IsNullOrEmpty(_key))
{
_key = Guid.NewGuid().ToString();
using (var connection = await _testFixture.GetTestDatabaseConnectionAsync())
{
SpannerCommand insupdate;
// 1st update
await connection.OpenAsync();
using (var tx = await connection.BeginTransactionAsync())
{
insupdate = connection.CreateInsertOrUpdateCommand(
"TX",
new SpannerParameterCollection
{
{ "K", SpannerDbType.String, _key },
{ "StringValue", SpannerDbType.String, Guid.NewGuid().ToString() }
});
insupdate.Transaction = tx;
await insupdate.ExecuteNonQueryAsync();
var timestamp = await tx.CommitAsync();
_history.Add(
new HistoryEntry
{
Value = insupdate.Parameters[1].Value.ToString(),
Timestamp = timestamp.GetValueOrDefault()
});
}
await Task.Delay(250);
// 2nd update
using (var tx = await connection.BeginTransactionAsync())
{
insupdate.Transaction = tx;
insupdate.CommandText = "UPDATE TX";
insupdate.Parameters[1].Value = Guid.NewGuid().ToString();
await insupdate.ExecuteNonQueryAsync();
var timestamp = await tx.CommitAsync();
_history.Add(
new HistoryEntry
{
Value = insupdate.Parameters[1].Value.ToString(),
Timestamp = timestamp.GetValueOrDefault()
});
}
await Task.Delay(250);
// 3rd update
using (var tx = await connection.BeginTransactionAsync())
{
insupdate.Transaction = tx;
insupdate.Parameters[1].Value = Guid.NewGuid().ToString();
await insupdate.ExecuteNonQueryAsync();
var timestamp = await tx.CommitAsync();
_history.Add(
new HistoryEntry
{
Value = insupdate.Parameters[1].Value.ToString(),
Timestamp = timestamp.GetValueOrDefault()
});
}
}
}
}