public void TestMRangeReduce()
{
IDatabase db = redisFixture.Redis.GetDatabase();
foreach (var key in keys)
{
var label = new TimeSeriesLabel("key", "MRangeReduce");
db.TimeSeriesCreate(key, labels: new List <TimeSeriesLabel> {
label
});
}
var tuples = CreateData(db, 50);
var results = db.TimeSeriesMRange("-", "+", new List <string> {
"key=MRangeReduce"
}, withLabels: true, groupbyTuple: ("key", TsReduce.Sum));
Assert.Equal(1, results.Count);
Assert.Equal("key=MRangeReduce", results[0].key);
Assert.Equal(new TimeSeriesLabel("key", "MRangeReduce"), results[0].labels[0]);
Assert.Equal(new TimeSeriesLabel("__reducer__", "sum"), results[0].labels[1]);
Assert.Equal(new TimeSeriesLabel("__source__", string.Join(",", keys)), results[0].labels[2]);
for (int i = 0; i < results[0].values.Count; i++)
{
Assert.Equal(tuples[i].Val * 2, results[0].values[i].Val);
}
}
public async Task TestMGetQueryWithLabels()
{
var keys = CreateKeyNames(2);
var db = redisFixture.Redis.GetDatabase();
var label1 = new TimeSeriesLabel(keys[0], "value");
var label2 = new TimeSeriesLabel(keys[1], "value2");
var labels1 = new List <TimeSeriesLabel> {
label1, label2
};
var labels2 = new List <TimeSeriesLabel> {
label1
};
var ts1 = await db.TimeSeriesAddAsync(keys[0], "*", 1.1, labels : labels1);
var tuple1 = new TimeSeriesTuple(ts1, 1.1);
var ts2 = await db.TimeSeriesAddAsync(keys[1], "*", 2.2, labels : labels2);
var tuple2 = new TimeSeriesTuple(ts2, 2.2);
var results = await db.TimeSeriesMGetAsync(new List <string> {
$"{keys[0]}=value"
}, withLabels : true);
Assert.Equal(2, results.Count);
Assert.Equal(keys[0], results[0].key);
Assert.Equal(tuple1, results[0].value);
Assert.Equal(labels1, results[0].labels);
Assert.Equal(keys[1], results[1].key);
Assert.Equal(tuple2, results[1].value);
Assert.Equal(labels2, results[1].labels);
}
public void TestMRangeGroupby()
{
IDatabase db = redisFixture.Redis.GetDatabase();
for (int i = 0; i < keys.Length; i++)
{
var label1 = new TimeSeriesLabel("key", "MRangeGroupby");
var label2 = new TimeSeriesLabel("group", i.ToString());
db.TimeSeriesCreate(keys[i], labels: new List <TimeSeriesLabel> {
label1, label2
});
}
var tuples = CreateData(db, 50);
var results = db.TimeSeriesMRange("-", "+", new List <string> {
"key=MRangeGroupby"
}, withLabels: true, groupbyTuple: ("group", TsReduce.Min));
Assert.Equal(keys.Length, results.Count);
for (int i = 0; i < results.Count; i++)
{
Assert.Equal("group=" + i, results[i].key);
Assert.Equal(new TimeSeriesLabel("group", i.ToString()), results[i].labels[0]);
Assert.Equal(new TimeSeriesLabel("__reducer__", "min"), results[i].labels[1]);
Assert.Equal(new TimeSeriesLabel("__source__", keys[i]), results[i].labels[2]);
Assert.Equal(tuples, results[i].values);
}
}
public async Task TestMRangeWithLabels()
{
var keys = CreateKeyNames(2);
var db = redisFixture.Redis.GetDatabase();
var label = new TimeSeriesLabel(keys[0], "value");
var labels = new List <TimeSeriesLabel> {
label
};
foreach (var key in keys)
{
await db.TimeSeriesCreateAsync(key, labels : labels);
}
var tuples = await CreateData(db, keys, 50);
var results = await db.TimeSeriesMRangeAsync("-", "+", new List <string> {
$"{keys[0]}=value"
}, withLabels : true);
Assert.Equal(keys.Length, results.Count);
for (var i = 0; i < results.Count; i++)
{
Assert.Equal(keys[i], results[i].key);
Assert.Equal(labels, results[i].labels);
Assert.Equal(tuples, results[i].values);
}
}
public void TestMGetQueryWithLabels()
{
IDatabase db = redisFixture.Redis.GetDatabase();
var label1 = new TimeSeriesLabel("MGET_TESTS_1", "value");
var label2 = new TimeSeriesLabel("MGET_TESTS_2", "value2");
var labels1 = new List <TimeSeriesLabel> {
label1, label2
};
var labels2 = new List <TimeSeriesLabel> {
label1
};
TimeStamp ts1 = db.TimeSeriesAdd(keys[0], "*", 1.1, labels: labels1);
TimeSeriesTuple tuple1 = new TimeSeriesTuple(ts1, 1.1);
TimeStamp ts2 = db.TimeSeriesAdd(keys[1], "*", 2.2, labels: labels2);
TimeSeriesTuple tuple2 = new TimeSeriesTuple(ts2, 2.2);
var results = db.TimeSeriesMGet(new List <string> {
"MGET_TESTS_1=value"
}, withLabels: true);
Assert.Equal(2, results.Count);
Assert.Equal(keys[0], results[0].key);
Assert.Equal(tuple1, results[0].value);
Assert.Equal(labels1, results[0].labels);
Assert.Equal(keys[1], results[1].key);
Assert.Equal(tuple2, results[1].value);
Assert.Equal(labels2, results[1].labels);
}
public void TestLabelConstructor()
{
TimeSeriesLabel label = new TimeSeriesLabel("a", "b");
Assert.Equal("a", label.Key);
Assert.Equal("b", label.Value);
}
public void TestMRangeWithLabels()
{
IDatabase db = redisFixture.Redis.GetDatabase();
TimeSeriesLabel label = new TimeSeriesLabel("key", "MRangeWithLabels");
var labels = new List <TimeSeriesLabel> {
label
};
foreach (string key in keys)
{
db.TimeSeriesCreate(key, labels: labels);
}
var tuples = CreateData(db, 50);
var results = db.TimeSeriesMRange("-", "+", new List <string> {
"key=MRangeWithLabels"
}, withLabels: true);
Assert.Equal(keys.Length, results.Count);
for (int i = 0; i < results.Count; i++)
{
Assert.Equal(keys[i], results[i].key);
Assert.Equal(labels, results[i].labels);
Assert.Equal(tuples, results[i].values);
}
}
public void TestMRangeAggregation()
{
IDatabase db = redisFixture.Redis.GetDatabase();
TimeSeriesLabel labal = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
labal
};
foreach (string key in keys)
{
db.TimeSeriesCreate(key, labels: labels);
}
var tuples = CreateData(db, 50);
var results = db.TimeSeriesMRange("-", "+", new List <string> {
"key=value"
}, aggregation: Aggregation.MIN, timeBucket: 50);
Assert.Equal(keys.Length, results.Count);
for (int i = 0; i < results.Count; i++)
{
Assert.Equal(keys[i], results[i].key);
Assert.Equal(0, results[i].labels.Count);
Assert.Equal(tuples, results[i].values);
}
}
public async Task TestMissingTimeBucket()
{
var keys = CreateKeyNames(2);
var db = redisFixture.Redis.GetDatabase();
var label = new TimeSeriesLabel(keys[0], "value");
var labels = new List <TimeSeriesLabel> {
label
};
foreach (var key in keys)
{
await db.TimeSeriesCreateAsync(key, labels : labels);
}
var tuples = await CreateData(db, keys, 50);
var ex = await Assert.ThrowsAsync <ArgumentException>(async() =>
{
await db.TimeSeriesMRangeAsync("-", "+",
filter: new List <string>()
{
$"key=value"
},
aggregation: TsAggregation.Avg);
});
Assert.Equal("RANGE Aggregation should have timeBucket value", ex.Message);
}
public async Task TestMRangeReduce()
{
var keys = CreateKeyNames(2);
var db = redisFixture.Redis.GetDatabase();
foreach (var key in keys)
{
var label = new TimeSeriesLabel(keys[0], "value");
await db.TimeSeriesCreateAsync(key, labels : new List <TimeSeriesLabel> {
label
});
}
var tuples = await CreateData(db, keys, 50);
var results = await db.TimeSeriesMRangeAsync("-", "+", new List <string> {
$"{keys[0]}=value"
}, withLabels : true, groupbyTuple : (keys[0], TsReduce.Sum));
Assert.Equal(1, results.Count);
Assert.Equal($"{keys[0]}=value", results[0].key);
Assert.Equal(new TimeSeriesLabel(keys[0], "value"), results[0].labels[0]);
Assert.Equal(new TimeSeriesLabel("__reducer__", "sum"), results[0].labels[1]);
Assert.Equal(new TimeSeriesLabel("__source__", string.Join(",", keys)), results[0].labels[2]);
for (int i = 0; i < results[0].values.Count; i++)
{
Assert.Equal(tuples[i].Val * 2, results[0].values[i].Val);
}
}
public async Task TestMRangeGroupby()
{
var keys = CreateKeyNames(2);
var db = redisFixture.Redis.GetDatabase();
for (int i = 0; i < keys.Length; i++)
{
var label1 = new TimeSeriesLabel(keys[0], "value");
var label2 = new TimeSeriesLabel("group", i.ToString());
await db.TimeSeriesCreateAsync(keys[i], labels : new List <TimeSeriesLabel> {
label1, label2
});
}
var tuples = await CreateData(db, keys, 50);
var results = await db.TimeSeriesMRangeAsync("-", "+", new List <string> {
$"{keys[0]}=value"
}, withLabels : true, groupbyTuple : ("group", TsReduce.Min));
Assert.Equal(keys.Length, results.Count);
for (int i = 0; i < results.Count; i++)
{
Assert.Equal("group=" + i, results[i].key);
Assert.Equal(new TimeSeriesLabel("group", i.ToString()), results[i].labels[0]);
Assert.Equal(new TimeSeriesLabel("__reducer__", "min"), results[i].labels[1]);
Assert.Equal(new TimeSeriesLabel("__source__", keys[i]), results[i].labels[2]);
Assert.Equal(tuples, results[i].values);
}
}
public async Task TestTSQueryIndex()
{
var keys = CreateKeyNames(2);
var db = redisFixture.Redis.GetDatabase();
var label1 = new TimeSeriesLabel(keys[0], "value");
var label2 = new TimeSeriesLabel(keys[1], "value2");
var labels1 = new List <TimeSeriesLabel> {
label1, label2
};
var labels2 = new List <TimeSeriesLabel> {
label1
};
await db.TimeSeriesCreateAsync(keys[0], labels : labels1);
await db.TimeSeriesCreateAsync(keys[1], labels : labels2);
Assert.Equal(keys, db.TimeSeriesQueryIndex(new List <string> {
$"{keys[0]}=value"
}));
Assert.Equal(new List <string> {
keys[0]
}, db.TimeSeriesQueryIndex(new List <string> {
$"{keys[1]}=value2"
}));
}
public void TestSimpleMRevRange()
{
var keys = CreateKeyNames(2);
var db = redisFixture.Redis.GetDatabase();
var label = new TimeSeriesLabel(keys[0], "value");
var labels = new List <TimeSeriesLabel> {
label
};
foreach (var key in keys)
{
db.TimeSeriesCreate(key, labels: labels);
}
var tuples = CreateData(db, keys, 50);
var results = db.TimeSeriesMRevRange("-", "+", new List <string> {
$"{keys[0]}=value"
});
Assert.Equal(keys.Length, results.Count);
for (var i = 0; i < results.Count; i++)
{
Assert.Equal(keys[i], results[i].key);
Assert.Equal(0, results[i].labels.Count);
Assert.Equal(ReverseData(tuples), results[i].values);
}
}
public void TestLbaelEquals()
{
TimeSeriesLabel label_ab = new TimeSeriesLabel("a", "b");
TimeSeriesLabel label1 = new TimeSeriesLabel("a", "b");
TimeSeriesLabel label2 = new TimeSeriesLabel("a", "c");
TimeSeriesLabel label3 = new TimeSeriesLabel("c", "b");
Assert.Equal(label_ab, label1);
Assert.NotEqual(label_ab, label2);
Assert.NotEqual(label_ab, label3);
}
public void TestLabelHashCode()
{
TimeSeriesLabel label_ab = new TimeSeriesLabel("a", "b");
TimeSeriesLabel label1 = new TimeSeriesLabel("a", "b");
TimeSeriesLabel label2 = new TimeSeriesLabel("a", "c");
TimeSeriesLabel label3 = new TimeSeriesLabel("c", "b");
Assert.Equal(label_ab.GetHashCode(), label1.GetHashCode());
Assert.NotEqual(label_ab.GetHashCode(), label2.GetHashCode());
Assert.NotEqual(label_ab.GetHashCode(), label3.GetHashCode());
}
/// <summary>
/// Example for setting the last sample timestamp to system time and its value to 5, with INCRBY.
/// The parameters retentionTime, uncompressed and labels are optional and can be set in any order when used as named argument.
/// </summary>
public static void ParameterizedIncrByExample()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
IDatabase db = redis.GetDatabase();
var label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
db.TimeSeriesIncrBy("my_ts", 5, timestamp: "*", retentionTime: 5000, uncompressed: true, labels: labels);
redis.Close();
}
/// <summary>
/// Example for time-series creation parameters with ADD.
/// Named arguments are used in the same manner of TimeSeriesCreate.
/// </summary>
public static void ParameterizedAdd()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
IDatabase db = redis.GetDatabase();
TimeStamp timestamp = "*";
var label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
db.TimeSeriesAdd("my_ts", timestamp, 0.0, retentionTime: 5000, labels: labels, uncompressed: true);
redis.Close();
}
public void TestCreateLabels()
{
TimeSeriesLabel label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
IDatabase db = redisFixture.Redis.GetDatabase();
Assert.True(db.TimeSeriesCreate(key, labels: labels));
TimeSeriesInformation info = db.TimeSeriesInfo(key);
Assert.Equal(labels, info.Labels);
}
/// <summary>
/// Examples for altering time-series.
/// The parameters retentionTime, and labels are optional and can be set in any order when used as named argument.
/// </summary>
public static void ParameterizedAlter()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
IDatabase db = redis.GetDatabase();
var label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
db.TimeSeriesAlter("labeld_ts", labels: labels);
db.TimeSeriesAlter("retention_time_ts", retentionTime: 5000);
db.TimeSeriesAlter("parameterized_ts", retentionTime: 5000, labels: labels);
redis.Close();
}
/// <summary>
/// Example for time-series creation parameters with ADD.
/// Named arguments are used in the same manner of TimeSeriesCreate
/// </summary>
public static async Task ParameterizedAddAsync()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
IDatabase db = redis.GetDatabase();
TimeStamp timestamp = "*";
var label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
var policy = TsDuplicatePolicy.SUM;
await db.TimeSeriesAddAsync("my_ts", timestamp, 0.0, retentionTime : 5000, labels : labels, uncompressed : true, policy : policy);
redis.Close();
}
public void TestDefaultIncrByWithLabels()
{
double value = 5.5;
TimeSeriesLabel label = new TimeSeriesLabel("key", "value");
IDatabase db = redisFixture.Redis.GetDatabase();
var labels = new List <TimeSeriesLabel> {
label
};
Assert.True(db.TimeSeriesIncrBy(key, value, labels: labels) > 0);
Assert.Equal(value, db.TimeSeriesGet(key).Val);
TimeSeriesInformation info = db.TimeSeriesInfo(key);
Assert.Equal(labels, info.Labels);
}
public async Task TestCreateLabels()
{
var key = CreateKeyName();
var label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
var db = redisFixture.Redis.GetDatabase();
Assert.True(await db.TimeSeriesCreateAsync(key, labels: labels));
var info = await db.TimeSeriesInfoAsync(key);
Assert.Equal(labels, info.Labels);
}
public void TestAddWithLabels()
{
IDatabase db = redisFixture.Redis.GetDatabase();
TimeStamp now = DateTime.Now;
TimeSeriesLabel label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
Assert.Equal(now, db.TimeSeriesAdd(key, now, 1.1, labels: labels));
TimeSeriesInformation info = db.TimeSeriesInfo(key);
Assert.Equal(now, info.FirstTimeStamp);
Assert.Equal(now, info.LastTimeStap);
Assert.Equal(labels, info.Labels);
}
/// <summary>
/// Examples for creating time-series with parameters.
/// The parameters retentionTime, uncompressed and labels are optional and can be set in any order when used as named argument.
/// </summary>
public static void ParameterizedCreate()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
IDatabase db = redis.GetDatabase();
db.TimeSeriesCreate("retentionTime_ts", retentionTime: 5000);
db.TimeSeriesCreate("uncompressed_ts", uncompressed: true);
var label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
db.TimeSeriesCreate("labeled_ts", labels: labels);
db.TimeSeriesCreate("parameterized_ts", labels: labels, uncompressed: true, retentionTime: 5000);
redis.Close();
}
public void TestMissingFilter()
{
IDatabase db = redisFixture.Redis.GetDatabase();
TimeSeriesLabel label = new TimeSeriesLabel("key", "MissingFilter");
var labels = new List <TimeSeriesLabel> {
label
};
foreach (string key in keys)
{
db.TimeSeriesCreate(key, labels: labels);
}
var tuples = CreateData(db, 50);
var ex = Assert.Throws <ArgumentException>(() => db.TimeSeriesMRange("-", "+", new List <string>()));
Assert.Equal("There should be at least one filter on MRANGE/MREVRANGE", ex.Message);
}
public async Task TestAddWithLabels()
{
var key = CreateKeyName();
var db = redisFixture.Redis.GetDatabase();
TimeStamp timeStamp = DateTime.UtcNow;
var label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.1, labels: labels));
var info = await db.TimeSeriesInfoAsync(key);
Assert.Equal(timeStamp, info.FirstTimeStamp);
Assert.Equal(timeStamp, info.LastTimeStamp);
Assert.Equal(labels, info.Labels);
}
/// <summary>
/// Examples for creating time-series with parameters.
/// The parameters retentionTime, uncompressed and labels are optional and can be set in any order when used as named argument.
/// </summary>
public static async Task ParameterizedCreateAsync()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
IDatabase db = redis.GetDatabase();
await db.TimeSeriesCreateAsync("retentionTime_ts", retentionTime : 5000);
await db.TimeSeriesCreateAsync("uncompressed_ts", uncompressed : true);
var label = new TimeSeriesLabel("key", "value");
var labels = new List <TimeSeriesLabel> {
label
};
await db.TimeSeriesCreateAsync("labeled_ts", labels : labels);
await db.TimeSeriesCreateAsync("parameterized_ts", labels : labels, uncompressed : true, retentionTime : 5000, duplicatePolicy : TsDuplicatePolicy.LAST);
redis.Close();
}
public void TestMRangeFilter()
{
IDatabase db = redisFixture.Redis.GetDatabase();
TimeSeriesLabel label = new TimeSeriesLabel("key", "MRangeFilter");
var labels = new List <TimeSeriesLabel> {
label
};
db.TimeSeriesCreate(keys[0], labels: labels);
var tuples = CreateData(db, 50);
var results = db.TimeSeriesMRange("-", "+", new List <string> {
"key=MRangeFilter"
});
Assert.Equal(1, results.Count);
Assert.Equal(keys[0], results[0].key);
Assert.Equal(0, results[0].labels.Count);
Assert.Equal(tuples, results[0].values);
}
public void TestMissingFilter()
{
var keys = CreateKeyNames(2);
var db = redisFixture.Redis.GetDatabase();
var label = new TimeSeriesLabel(keys[0], "value");
var labels = new List <TimeSeriesLabel> {
label
};
foreach (var key in keys)
{
db.TimeSeriesCreateAsync(key, labels: labels);
}
var tuples = CreateData(db, keys, 50);
var ex = Assert.Throws <ArgumentException>(() => db.TimeSeriesMRevRange("-", "+", new List <string>()));
Assert.Equal("There should be at least one filter on MRANGE/MREVRANGE", ex.Message);
}
public void TestMRevRangeFilter()
{
var keys = CreateKeyNames(2);
var db = redisFixture.Redis.GetDatabase();
var label = new TimeSeriesLabel(keys[0], "value");
var labels = new List <TimeSeriesLabel> {
label
};
db.TimeSeriesCreateAsync(keys[0], labels: labels);
var tuples = CreateData(db, keys, 50);
var results = db.TimeSeriesMRevRange("-", "+", new List <string> {
$"{keys[0]}=value"
});
Assert.Equal(1, results.Count);
Assert.Equal(keys[0], results[0].key);
Assert.Equal(0, results[0].labels.Count);
Assert.Equal(ReverseData(tuples), results[0].values);
}
