public async Task Should_Write_Query_With_String_In_Dictionary_Binding(int rows, int startYear, string tableName)
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(startYear, 1, 1, 1, 1, 1, DateTimeKind.Utc), rows, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, tableName, infos);
var secondResultSet = await _client.ReadAsync <ComputerInfo>(
InfluxClientFixture.DatabaseName, $"select * from {tableName} where host = $host",
new Dictionary <string, object> {
{ "host", InfluxClientFixture.Hosts[0] }
});
var result = secondResultSet.Results[0];
Assert.Equal(1, result.Series.Count);
}
public async Task Should_Write_Typed_Rows_To_Database(int rows, int startYear, string tableName)
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(startYear, 1, 1, 1, 1, 1, DateTimeKind.Utc), rows, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, tableName, infos);
var secondResultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"select * from {tableName}");
var result = secondResultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(rows, series.Rows.Count);
}
public async Task Should_Show_Tag_Values()
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2014, 1, 1, 1, 1, 1, DateTimeKind.Utc), 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "set5Measurement", infos);
var result = await _client.ShowTagValuesAsync <RegionRow>(InfluxClientFixture.DatabaseName, "region", "set5Measurement");
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
foreach (var region in InfluxClientFixture.Regions)
{
Assert.Contains(series.Rows, x => x.Region == region);
}
}
public async Task Should_Show_Series()
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2010, 1, 1, 1, 1, 1, DateTimeKind.Utc), 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "set1Measurement", infos);
var result = await _client.ShowSeriesAsync(InfluxClientFixture.DatabaseName, "set1Measurement");
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
foreach (var key in InfluxClientFixture.GenerateShowSeriesKeysFor("set1Measurement"))
{
Assert.Contains(key, series.Rows.Select(x => x.Key));
}
}
public async Task Should_Write_And_Query_Deferred_Grouped_Data_With_Multi_Query(int count, char c, bool useDefaultOptions)
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, count, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, $"groupedComputerInfo4{c}", infos);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, $"groupedComputerInfo5{c}", infos);
InfluxChunkedResultSet <ComputerInfo> chunkedResultSet;
if (useDefaultOptions)
{
chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo4{c} GROUP BY region;SELECT * FROM groupedComputerInfo5{c} GROUP BY region");
}
else
{
chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo4{c} GROUP BY region;SELECT * FROM groupedComputerInfo5{c} GROUP BY region", new InfluxQueryOptions { ChunkSize = 200 });
}
InfluxChunkedResult <ComputerInfo> currentResult;
InfluxChunkedSeries <ComputerInfo> currentSerie;
InfluxChunk <ComputerInfo> currentChunk;
int resultCount = 0;
int serieCount = 0;
int rowCount = 0;
using ( chunkedResultSet )
{
while ((currentResult = await chunkedResultSet.GetNextResultAsync()) != null)
{
while ((currentSerie = await currentResult.GetNextSeriesAsync()) != null)
{
while ((currentChunk = await currentSerie.GetNextChunkAsync()) != null)
{
rowCount += currentChunk.Rows.Count;
}
serieCount++;
}
resultCount++;
}
}
Assert.Equal(1 * 2, resultCount);
Assert.Equal(InfluxClientFixture.Regions.Length * 2, serieCount);
Assert.Equal(count * 2, rowCount);
}
public async Task Should_Write_Typed_Rows_To_Database_With_Chunking()
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2010, 1, 1, 1, 1, 1, DateTimeKind.Utc), 20000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "computerInfo1", infos);
var resultSet = await _client.ReadAsync <ComputerInfo>(
InfluxClientFixture.DatabaseName,
"select * from computerInfo1",
new InfluxQueryOptions { ChunkSize = 1000 });
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(20000, series.Rows.Count);
}
public async Task Should_Write_And_Query_Deferred_Grouped_Data_Breaking_2()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo9", infos);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo10", infos);
var chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo9 GROUP BY region;SELECT * FROM groupedComputerInfo10 GROUP BY region", new InfluxQueryOptions { ChunkSize = 200 });
InfluxChunkedResult <ComputerInfo> currentResult;
InfluxChunkedSeries <ComputerInfo> currentSerie;
InfluxChunk <ComputerInfo> currentChunk;
int resultCount = 0;
int serieCount = 0;
int rowCount = 0;
HashSet <string> measurements = new HashSet <string>();
using ( chunkedResultSet )
{
while ((currentResult = await chunkedResultSet.GetNextResultAsync()) != null)
{
while ((currentSerie = await currentResult.GetNextSeriesAsync()) != null)
{
while ((currentChunk = await currentSerie.GetNextChunkAsync()) != null)
{
rowCount += currentChunk.Rows.Count;
break;
}
measurements.Add(currentSerie.Name);
serieCount++;
break;
}
resultCount++;
}
}
Assert.Equal(2, resultCount);
Assert.Equal(2, serieCount);
Assert.Equal(400, rowCount);
Assert.True(measurements.Contains("groupedComputerInfo9"));
Assert.True(measurements.Contains("groupedComputerInfo10"));
}
public async Task Should_Write_And_Query_Grouped_Data()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo1", infos);
var resultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo1 GROUP BY region");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
foreach (var region in InfluxClientFixture.Regions)
{
var kvp = new KeyValuePair <string, object>("region", region);
var group = result.FindGroup("groupedComputerInfo1", new[] { kvp });
Assert.NotNull(group);
}
}
public async Task Should_Write_And_Query_Deferred_Data()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo7", infos);
var chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo7", new InfluxQueryOptions { ChunkSize = 200 });
InfluxChunkedResult <ComputerInfo> currentResult;
InfluxChunkedSeries <ComputerInfo> currentSerie;
InfluxChunk <ComputerInfo> currentChunk;
int resultCount = 0;
int serieCount = 0;
int rowCount = 0;
HashSet <DateTime> times = new HashSet <DateTime>();
using ( chunkedResultSet )
{
while ((currentResult = await chunkedResultSet.GetNextResultAsync()) != null)
{
while ((currentSerie = await currentResult.GetNextSeriesAsync()) != null)
{
while ((currentChunk = await currentSerie.GetNextChunkAsync()) != null)
{
foreach (var row in currentChunk.Rows)
{
Assert.False(times.Contains(row.Timestamp));
times.Add(row.Timestamp);
}
rowCount += currentChunk.Rows.Count;
}
serieCount++;
}
resultCount++;
}
}
Assert.Equal(1, resultCount);
Assert.Equal(1, serieCount);
Assert.Equal(5000, rowCount);
}
public async Task Should_Write_And_Query_Grouped_Data_Using_Computed_Columns()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
var end = infos.Last().Timestamp;
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo3", infos);
var resultSet = await _client.ReadAsync <ComputedComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT MEAN(cpu) AS cpu, COUNT(ram) AS ram FROM groupedComputerInfo3 WHERE time >= '{start.ToIso8601()}' AND time <= '{end.ToIso8601()}' GROUP BY time(1ms), region fill(none)");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
foreach (var region in InfluxClientFixture.Regions)
{
var kvp = new KeyValuePair <string, object>("region", region);
var group = result.FindGroup("groupedComputerInfo3", new[] { kvp });
Assert.NotNull(group);
}
}
public async Task Should_Write_Different_Types_Of_Rows_To_Database(int rows, int startYear, string tableName)
{
var start1 = new DateTime(startYear, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var typedInfos = InfluxClientFixture.CreateTypedRowsStartingAt(start1, rows, false);
var start2 = start1.AddYears(1);
var dynamicInfos = InfluxClientFixture.CreateDynamicRowsStartingAt(start1, rows);
List <object> items = new List <object>();
foreach (var t in typedInfos)
{
items.Add(t);
}
foreach (var d in dynamicInfos)
{
items.Add(d);
}
await _client.WriteAsync(InfluxClientFixture.DatabaseName, tableName, items);
}
public async Task Should_Write_And_Read_Data_From_Non_Default_RP()
{
_client.CreateRetentionPolicyAsync(InfluxClientFixture.DatabaseName, RpName, "2h2m", 1, false).Wait();
var rps = await _client.ShowRetentionPoliciesAsync(InfluxClientFixture.DatabaseName);
Assert.True(rps.Succeeded);
Assert.Equal(1, rps.Series.Count);
var rpSeries = rps.Series[0];
Assert.Equal(2, rpSeries.Rows.Count);
var policy = rpSeries.Rows.FirstOrDefault(row => row.Name == RpName);
Assert.NotNull(policy);
Assert.Equal("2h2m0s", policy.Duration);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(DateTime.UtcNow.AddHours(-2), 2 * 60 * 60, false);
var options = new InfluxWriteOptions
{
RetentionPolicy = RpName
};
_client.WriteAsync(InfluxClientFixture.DatabaseName, MeasurementName, infos, options).Wait();
var resultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM {RpName}.{MeasurementName}");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(2 * 60 * 60, series.Rows.Count);
await _client.DropRetentionPolicyAsync(InfluxClientFixture.DatabaseName, RpName);
}
public async Task Should_Write_And_Query_Typed_Data()
{
var start = new DateTime(2013, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 500, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "computerInfo", infos);
var from = start;
var to = from.AddSeconds(250);
var resultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM computerInfo WHERE '{from.ToIso8601()}' <= time AND time < '{to.ToIso8601()}'");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(250, series.Rows.Count);
}
public async Task Should_Write_And_Query_Deferred_Grouped_Data_Breaking()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo8", infos);
var chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo8 GROUP BY region", new InfluxQueryOptions { ChunkSize = 200 });
InfluxChunkedResult <ComputerInfo> currentResult;
InfluxChunkedSeries <ComputerInfo> currentSerie;
InfluxChunk <ComputerInfo> currentChunk;
int resultCount = 0;
int serieCount = 0;
int rowCount = 0;
using ( chunkedResultSet )
{
while ((currentResult = await chunkedResultSet.GetNextResultAsync()) != null)
{
while ((currentSerie = await currentResult.GetNextSeriesAsync()) != null)
{
while ((currentChunk = await currentSerie.GetNextChunkAsync()) != null)
{
rowCount += currentChunk.Rows.Count;
break;
}
serieCount++;
}
resultCount++;
}
}
Assert.Equal(1, resultCount);
Assert.Equal(InfluxClientFixture.Regions.Length, serieCount);
Assert.Equal(1000, rowCount);
}
public async Task Should_Write_Typed_Rows_With_Nulls_To_Database(int rows, int startYear)
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(startYear, 1, 1, 1, 1, 1, DateTimeKind.Utc), rows, true);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "computerInfo3", infos);
}
public async Task Should_Write_Typed_Rows_To_Database(int rows)
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2010, 1, 1, 1, 1, 1, DateTimeKind.Utc), rows, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "computerInfo", infos);
}
