Time series

> TS.CREATE thermometer:1
OK
> TYPE thermometer:1
TSDB-TYPE
> TS.INFO thermometer:1
 1) totalSamples
 2) (integer) 0
    .
    .

"""
Code samples for time series page:
    https://redis.io/docs/latest/develop/data-types/timeseries/
"""

import redis

r = redis.Redis(decode_responses=True)


res1 = r.ts().create("thermometer:1")
print(res1)  # >>> True

res2 = r.type("thermometer:1")
print(res2)  # >>> TSDB-TYPE

res3 = r.ts().info("thermometer:1")
print(res3)
# >>> {'rules': [], ... 'total_samples': 0, ...

res4 = r.ts().add("thermometer:2", 1, 10.8, retention_msecs=100)
print(res4)  # >>> 1

res5 = r.ts().info("thermometer:2")
print(res5)
# >>> {'rules': [], ... 'retention_msecs': 100, ...

res6 = r.ts().create(
    "thermometer:3", 1, 10.4,
    labels={"location": "UK", "type": "Mercury"}
)
print(res6)  # >>> 1

res7 = r.ts().info("thermometer:3")
print(res7)
# >>> {'rules': [], ... 'labels': {'location': 'UK', 'type': 'Mercury'}, ...

res8 = r.ts().madd([
    ("thermometer:1", 1, 9.2),
    ("thermometer:1", 2, 9.9),
    ("thermometer:2", 2, 10.3)
])
print(res8)  # >>> [1, 2, 2]

# The last recorded temperature for thermometer:2
# was 10.3 at time 2.
res9 = r.ts().get("thermometer:2")
print(res9)  # >>> (2, 10.3)

# Add 5 data points to a time series named "rg:1".
res10 = r.ts().create("rg:1")
print(res10)  # >>> True

res11 = r.ts().madd([
        ("rg:1", 0, 18),
        ("rg:1", 1, 14),
        ("rg:1", 2, 22),
        ("rg:1", 3, 18),
        ("rg:1", 4, 24),
])
print(res11)  # >>> [0, 1, 2, 3, 4]

# Retrieve all the data points in ascending order.
res12 = r.ts().range("rg:1", "-", "+")
print(res12)  # >>> [(0, 18.0), (1, 14.0), (2, 22.0), (3, 18.0), (4, 24.0)]

# Retrieve data points up to time 1 (inclusive).
res13 = r.ts().range("rg:1", "-", 1)
print(res13)  # >>> [(0, 18.0), (1, 14.0)]

# Retrieve data points from time 3 onwards.
res14 = r.ts().range("rg:1", 3, "+")
print(res14)  # >>> [(3, 18.0), (4, 24.0)]

# Retrieve all the data points in descending order.
res15 = r.ts().revrange("rg:1", "-", "+")
print(res15)  # >>> [(4, 24.0), (3, 18.0), (2, 22.0), (1, 14.0), (0, 18.0)]

# Retrieve data points up to time 1 (inclusive), but return them
# in descending order.
res16 = r.ts().revrange("rg:1", "-", 1)
print(res16)  # >>> [(1, 14.0), (0, 18.0)]

res17 = r.ts().range("rg:1", "-", "+", filter_by_ts=[0, 2, 4])
print(res17)  # >>> [(0, 18.0), (2, 22.0), (4, 24.0)]

res18 = r.ts().revrange(
    "rg:1", "-", "+",
    filter_by_ts=[0, 2, 4],
    filter_by_min_value=20,
    filter_by_max_value=25,
)
print(res18)  # >>> [(4, 24.0), (2, 22.0)]

res19 = r.ts().revrange(
    "rg:1", "-", "+",
    filter_by_ts=[0, 2, 4],
    filter_by_min_value=22,
    filter_by_max_value=22,
    count=1,
)
print(res19)  # >>> [(2, 22.0)]

# Create three new "rg:" time series (two in the US
# and one in the UK, with different units) and add some
# data points.
res20 = r.ts().create(
    "rg:2",
    labels={"location": "us", "unit": "cm"},
)
print(res20)  # >>> True

res21 = r.ts().create(
    "rg:3",
    labels={"location": "us", "unit": "in"},
)
print(res21)  # >>> True

res22 = r.ts().create(
    "rg:4",
    labels={"location": "uk", "unit": "mm"},
)
print(res22)  # >>> True

res23 = r.ts().madd([
        ("rg:2", 0, 1.8),
        ("rg:3", 0, 0.9),
        ("rg:4", 0, 25),
])
print(res23)  # >>> [0, 0, 0]

res24 = r.ts().madd([
        ("rg:2", 1, 2.1),
        ("rg:3", 1, 0.77),
        ("rg:4", 1, 18),
])
print(res24)  # >>> [1, 1, 1]

res25 = r.ts().madd([
        ("rg:2", 2, 2.3),
        ("rg:3", 2, 1.1),
        ("rg:4", 2, 21),
])
print(res25)  # >>> [2, 2, 2]

res26 = r.ts().madd([
        ("rg:2", 3, 1.9),
        ("rg:3", 3, 0.81),
        ("rg:4", 3, 19),
])
print(res26)  # >>> [3, 3, 3]

res27 = r.ts().madd([
        ("rg:2", 4, 1.78),
        ("rg:3", 4, 0.74),
        ("rg:4", 4, 23),
])
print(res27)  # >>> [4, 4, 4]

# Retrieve the last data point from each US time series. If
# you don't specify any labels, an empty array is returned
# for the labels.
res28 = r.ts().mget(["location=us"])
print(res28)  # >>> [{'rg:2': [{}, 4, 1.78]}, {'rg:3': [{}, 4, 0.74]}]

# Retrieve the same data points, but include the `unit`
# label in the results.
res29 = r.ts().mget(["location=us"], select_labels=["unit"])
print(res29)  # >>> [{'unit': 'cm'}, (4, 1.78), {'unit': 'in'}, (4, 0.74)]

# Retrieve data points up to time 2 (inclusive) from all
# time series that use millimeters as the unit. Include all
# labels in the results.
res30 = r.ts().mrange(
    "-", 2, filters=["unit=mm"], with_labels=True
)
print(res30)
# >>> [{'rg:4': [{'location': 'uk', 'unit': 'mm'}, [(0, 25.4),...

# Retrieve data points from time 1 to time 3 (inclusive) from
# all time series that use centimeters or millimeters as the unit,
# but only return the `location` label. Return the results
# in descending order of timestamp.
res31 = r.ts().mrevrange(
    1, 3, filters=["unit=(cm,mm)"], select_labels=["location"]
)
print(res31)
# >>> [[{'location': 'uk'}, (3, 19.0), (2, 21.0), (1, 18.0)],...

res32 = r.ts().range(
    "rg:2", "-", "+",
    aggregation_type="avg",
    bucket_size_msec=2
)
print(res32)
# >>> [(0, 1.9500000000000002), (2, 2.0999999999999996), (4, 1.78)]

res33 = r.ts().create("sensor3")
print(res33)  # >>> True

res34 = r.ts().madd([
    ("sensor3", 10, 1000),
    ("sensor3", 20, 2000),
    ("sensor3", 30, 3000),
    ("sensor3", 40, 4000),
    ("sensor3", 50, 5000),
    ("sensor3", 60, 6000),
    ("sensor3", 70, 7000),
])
print(res34)  # >>> [10, 20, 30, 40, 50, 60, 70]

res35 = r.ts().range(
    "sensor3", 10, 70,
    aggregation_type="min",
    bucket_size_msec=25
)
print(res35)
# >>> [(0, 1000.0), (25, 3000.0), (50, 5000.0)]

res36 = r.ts().range(
    "sensor3", 10, 70,
    aggregation_type="min",
    bucket_size_msec=25,
    align="START"
)
print(res36)
# >>> [(10, 1000.0), (35, 4000.0), (60, 6000.0)]

res37 = r.ts().create(
    "wind:1",
    labels={"country": "uk"}
)
print(res37)  # >>> True

res38 = r.ts().create(
    "wind:2",
    labels={"country": "uk"}
)
print(res38)  # >>> True

res39 = r.ts().create(
    "wind:3",
    labels={"country": "us"}
)
print(res39)  # >>> True

res40 = r.ts().create(
    "wind:4",
    labels={"country": "us"}
)
print(res40)  # >>> True

res41 = r.ts().madd([
        ("wind:1", 1, 12),
        ("wind:2", 1, 18),
        ("wind:3", 1, 5),
        ("wind:4", 1, 20),
])
print(res41)  # >>> [1, 1, 1, 1]

res42 = r.ts().madd([
        ("wind:1", 2, 14),
        ("wind:2", 2, 21),
        ("wind:3", 2, 4),
        ("wind:4", 2, 25),
])
print(res42)  # >>> [2, 2, 2, 2]

res43 = r.ts().madd([
        ("wind:1", 3, 10),
        ("wind:2", 3, 24),
        ("wind:3", 3, 8),
        ("wind:4", 3, 18),
])
print(res43)  # >>> [3, 3, 3, 3]

# The result pairs contain the timestamp and the maximum sample value
# for the country at that timestamp.
res44 = r.ts().mrange(
    "-", "+",
    filters=["country=(us,uk)"],
    groupby="country",
    reduce="max"
)
print(res44)
# >>> [{'country=uk': [{}, [(1, 18.0), (2, 21.0), (3, 24.0)]]}, ...

# The result pairs contain the timestamp and the average sample value
# for the country at that timestamp.
res45 = r.ts().mrange(
    "-", "+",
    filters=["country=(us,uk)"],
    groupby="country",
    reduce="avg"
)
print(res45)
# >>> [{'country=uk': [{}, [(1, 15.0), (2, 17.5), (3, 17.0)]]}, ...

res45 = r.ts().create("hyg:1")
print(res45)  # >>> True

res46 = r.ts().create("hyg:compacted")
print(res46)  # >>> True

res47 = r.ts().createrule("hyg:1", "hyg:compacted", "min", 3)
print(res47)  # >>> True

res48 = r.ts().info("hyg:1")
print(res48.rules)
# >>> [['hyg:compacted', 3, 'MIN', 0]]

res49 = r.ts().info("hyg:compacted")
print(res49.source_key)  # >>> 'hyg:1'

res50 = r.ts().madd([
    ("hyg:1", 0, 75),
    ("hyg:1", 1, 77),
    ("hyg:1", 2, 78),
])
print(res50)  # >>> [0, 1, 2]

res51 = r.ts().range("hyg:compacted", "-", "+")
print(res51)  # >>> []

res52 = r.ts().add("hyg:1", 3, 79)
print(res52)  # >>> 3

res53 = r.ts().range("hyg:compacted", "-", "+")
print(res53)  # >>> [(0, 75.0)]

res54 = r.ts().info("thermometer:1")
print(res54.total_samples)  # >>> 2
print(res54.first_timestamp)  # >>> 1
print(res54.last_timestamp)  # >>> 2

res55 = r.ts().add("thermometer:1", 3, 9.7)
print(res55)  # >>> 3

res56 = r.ts().info("thermometer:1")
print(res56.total_samples)  # >>> 3
print(res56.first_timestamp)  # >>> 1
print(res56.last_timestamp)  # >>> 3

res57 = r.ts().delete("thermometer:1", 1, 2)
print(res57)  # >>> 2

res58 = r.ts().info("thermometer:1")
print(res58.total_samples)  # >>> 1
print(res58.first_timestamp)  # >>> 3
print(res58.last_timestamp)  # >>> 3

res59 = r.ts().delete("thermometer:1", 3, 3)
print(res59)  # >>> 1

res60 = r.ts().info("thermometer:1")
print(res60.total_samples)  # >>> 0

import assert from 'assert';
import { createClient } from 'redis';
import { TIME_SERIES_AGGREGATION_TYPE, TIME_SERIES_REDUCERS } from '@redis/time-series';

const client = createClient();
await client.connect();


const res1 = await client.ts.create('thermometer:1');
console.log(res1); // >>> OK

const res2 = await client.type('thermometer:1');
console.log(res2); // >>> TSDB-TYPE

const res3 = await client.ts.info('thermometer:1');
console.log(res3);
// >>> { rules: [], ... totalSamples: 0, ...

const res4 = await client.ts.add('thermometer:2', 1, 10.8, { RETENTION: 100 });
console.log(res4); // >>> 1

const res5 = await client.ts.info('thermometer:2');
console.log(res5);
// >>> { rules: [], ... retentionTime: 100, ...

const res6 = await client.ts.add('thermometer:3', 1, 10.4, {
  LABELS: { location: 'UK', type: 'Mercury' }
});
console.log(res6); // >>> 1

const res7 = await client.ts.info('thermometer:3');
console.log(res7);
// >>> { labels: [{ name: 'location', value: 'UK' }, { name: 'type', value: 'Mercury' }], ... }

const res8 = await client.ts.mAdd([
  { key: 'thermometer:1', timestamp: 1, value: 9.2 },
  { key: 'thermometer:1', timestamp: 2, value: 9.9 },
  { key: 'thermometer:2', timestamp: 2, value: 10.3 }
]);
console.log(res8); // >>> [1, 2, 2]

// The last recorded temperature for thermometer:2
// was 10.3 at time 2.
const res9 = await client.ts.get('thermometer:2');
console.log(res9); // >>> { timestamp: 2, value: 10.3 }

// Add 5 data points to a time series named "rg:1".
const res10 = await client.ts.create('rg:1');
console.log(res10); // >>> OK

const res11 = await client.ts.mAdd([
  { key: 'rg:1', timestamp: 0, value: 18 },
  { key: 'rg:1', timestamp: 1, value: 14 },
  { key: 'rg:1', timestamp: 2, value: 22 },
  { key: 'rg:1', timestamp: 3, value: 18 },
  { key: 'rg:1', timestamp: 4, value: 24 }
]);
console.log(res11); // >>> [0, 1, 2, 3, 4]

// Retrieve all the data points in ascending order.
const res12 = await client.ts.range('rg:1', '-', '+');
console.log(res12);
// >>> [{ timestamp: 0, value: 18 }, { timestamp: 1, value: 14 }, ...]

// Retrieve data points up to time 1 (inclusive).
const res13 = await client.ts.range('rg:1', '-', 1);
console.log(res13);
// >>> [{ timestamp: 0, value: 18 }, { timestamp: 1, value: 14 }]

// Retrieve data points from time 3 onwards.
const res14 = await client.ts.range('rg:1', 3, '+');
console.log(res14);
// >>> [{ timestamp: 3, value: 18 }, { timestamp: 4, value: 24 }]

// Retrieve all the data points in descending order.
const res15 = await client.ts.revRange('rg:1', '-', '+');
console.log(res15);
// >>> [{ timestamp: 4, value: 24 }, { timestamp: 3, value: 18 }, ...]

// Retrieve data points up to time 1 (inclusive), but return them
// in descending order.
const res16 = await client.ts.revRange('rg:1', '-', 1);
console.log(res16);
// >>> [{ timestamp: 1, value: 14 }, { timestamp: 0, value: 18 }]

const res17 = await client.ts.range('rg:1', '-', '+', {
  FILTER_BY_TS: [0, 2, 4]
});
console.log(res17);
// >>> [{ timestamp: 0, value: 18 }, { timestamp: 2, value: 22 }, { timestamp: 4, value: 24 }]

const res18 = await client.ts.revRange('rg:1', '-', '+', {
  FILTER_BY_TS: [0, 2, 4],
  FILTER_BY_VALUE: { min: 20, max: 25 }
});
console.log(res18);
// >>> [{ timestamp: 4, value: 24 }, { timestamp: 2, value: 22 }]

const res19 = await client.ts.revRange('rg:1', '-', '+', {
  FILTER_BY_TS: [0, 2, 4],
  FILTER_BY_VALUE: { min: 22, max: 22 },
  COUNT: 1
});
console.log(res19);
// >>> [{ timestamp: 2, value: 22 }]

// Create three new "rg:" time series (two in the US
// and one in the UK, with different units) and add some
// data points.
const res20 = await client.ts.create('rg:2', {
  LABELS: { location: 'us', unit: 'cm' }
});
console.log(res20); // >>> OK

const res21 = await client.ts.create('rg:3', {
  LABELS: { location: 'us', unit: 'in' }
});
console.log(res21); // >>> OK

const res22 = await client.ts.create('rg:4', {
  LABELS: { location: 'uk', unit: 'mm' }
});
console.log(res22); // >>> OK

const res23 = await client.ts.mAdd([
  { key: 'rg:2', timestamp: 0, value: 1.8 },
  { key: 'rg:3', timestamp: 0, value: 0.9 },
  { key: 'rg:4', timestamp: 0, value: 25 }
]);
console.log(res23); // >>> [0, 0, 0]

const res24 = await client.ts.mAdd([
  { key: 'rg:2', timestamp: 1, value: 2.1 },
  { key: 'rg:3', timestamp: 1, value: 0.77 },
  { key: 'rg:4', timestamp: 1, value: 18 }
]);
console.log(res24); // >>> [1, 1, 1]

const res25 = await client.ts.mAdd([
  { key: 'rg:2', timestamp: 2, value: 2.3 },
  { key: 'rg:3', timestamp: 2, value: 1.1 },
  { key: 'rg:4', timestamp: 2, value: 21 }
]);
console.log(res25); // >>> [2, 2, 2]

const res26 = await client.ts.mAdd([
  { key: 'rg:2', timestamp: 3, value: 1.9 },
  { key: 'rg:3', timestamp: 3, value: 0.81 },
  { key: 'rg:4', timestamp: 3, value: 19 }
]);
console.log(res26); // >>> [3, 3, 3]

const res27 = await client.ts.mAdd([
  { key: 'rg:2', timestamp: 4, value: 1.78 },
  { key: 'rg:3', timestamp: 4, value: 0.74 },
  { key: 'rg:4', timestamp: 4, value: 23 }
]);
console.log(res27); // >>> [4, 4, 4]

// Retrieve the last data point from each US time series.
const res28 = await client.ts.mGet(['location=us']);
console.log(res28);
// >>> { "rg:2": { sample: { timestamp: 4, value: 1.78 } }, "rg:3": { sample: { timestamp: 4, value: 0.74 } } }

// Retrieve the same data points, but include the `unit`
// label in the results.
const res29 = await client.ts.mGetSelectedLabels(['location=us'], ['unit']);
console.log(res29);
// >>> { "rg:2": { labels: { unit: 'cm' }, sample: { timestamp: 4, value: 1.78 } }, "rg:3": { labels: { unit: 'in' }, sample: { timestamp: 4, value: 0.74 } } }

// Retrieve data points up to time 2 (inclusive) from all
// time series that use millimeters as the unit. Include all
// labels in the results.
const res30 = await client.ts.mRangeWithLabels('-', 2, 'unit=mm');
console.log(res30);
// >>> { "rg:4": { labels: { location: 'uk', unit: 'mm' }, samples: [
//   { timestamp: 0, value: 25 },
//   { timestamp: 1, value: 18 },
//   { timestamp: 2, value: 21 }
// ] } }

// Retrieve data points from time 1 to time 3 (inclusive) from
// all time series that use centimeters or millimeters as the unit,
// but only return the `location` label. Return the results
// in descending order of timestamp.
const res31 = await client.ts.mRevRangeSelectedLabels(
  1, 3,
  ['location'],
  ['unit=(cm,mm)']
);
console.log(res31);
// >>> { "rg:2": { labels: { location: 'us' }, samples: [
//   { timestamp: 3, value: 1.9 },
//   { timestamp: 2, value: 2.3 },
//   { timestamp: 1, value: 2.1 }
// ] }, "rg:4": { labels: { location: 'uk' }, samples: [
//   { timestamp: 3, value: 19 },
//   { timestamp: 2, value: 21 },
//   { timestamp: 1, value: 18 }
// ] } }

const res32 = await client.ts.range('rg:2', '-', '+', {
  AGGREGATION: {
    type: TIME_SERIES_AGGREGATION_TYPE.AVG,
    timeBucket: 2
  }
});
console.log(res32);
// >>> [{ timestamp: 0, value: 1.9500000000000002 },{ timestamp: 2, value: 2.0999999999999996 }, { timestamp: 4, value: 1.78 }]

const res33 = await client.ts.create('sensor3');
console.log(res33); // >>> OK

const res34 = await client.ts.mAdd([
  { key: 'sensor3', timestamp: 10, value: 1000 },
  { key: 'sensor3', timestamp: 20, value: 2000 },
  { key: 'sensor3', timestamp: 30, value: 3000 },
  { key: 'sensor3', timestamp: 40, value: 4000 },
  { key: 'sensor3', timestamp: 50, value: 5000 },
  { key: 'sensor3', timestamp: 60, value: 6000 },
  { key: 'sensor3', timestamp: 70, value: 7000 }
]);
console.log(res34); // >>> [10, 20, 30, 40, 50, 60, 70]

const res35 = await client.ts.range('sensor3', 10, 70, {
  AGGREGATION: {
    type: TIME_SERIES_AGGREGATION_TYPE.MIN,
    timeBucket: 25
  }
});
console.log(res35);
// >>> [{ timestamp: 0, value: 1000 }, { timestamp: 25, value: 3000 }, { timestamp: 50, value: 5000 }]

const res36 = await client.ts.range('sensor3', 10, 70, {
  AGGREGATION: {
    type: TIME_SERIES_AGGREGATION_TYPE.MIN,
    timeBucket: 25
  },
  ALIGN: 'START'
});
console.log(res36);
// >>> [{ timestamp: 10, value: 1000 }, { timestamp: 35, value: 4000 }, { timestamp: 60, value: 6000 }]

const res37 = await client.ts.create('wind:1', {
  LABELS: { country: 'uk' }
});
console.log(res37); // >>> OK

const res38 = await client.ts.create('wind:2', {
  LABELS: { country: 'uk' }
});
console.log(res38); // >>> OK

const res39 = await client.ts.create('wind:3', {
  LABELS: { country: 'us' }
});
console.log(res39); // >>> OK

const res40 = await client.ts.create('wind:4', {
  LABELS: { country: 'us' }
});
console.log(res40); // >>> OK

const res41 = await client.ts.mAdd([
  { key: 'wind:1', timestamp: 1, value: 12 },
  { key: 'wind:2', timestamp: 1, value: 18 },
  { key: 'wind:3', timestamp: 1, value: 5 },
  { key: 'wind:4', timestamp: 1, value: 20 }
]);
console.log(res41); // >>> [1, 1, 1, 1]

const res42 = await client.ts.mAdd([
  { key: 'wind:1', timestamp: 2, value: 14 },
  { key: 'wind:2', timestamp: 2, value: 21 },
  { key: 'wind:3', timestamp: 2, value: 4 },
  { key: 'wind:4', timestamp: 2, value: 25 }
]);
console.log(res42); // >>> [2, 2, 2, 2]

const res43 = await client.ts.mAdd([
  { key: 'wind:1', timestamp: 3, value: 10 },
  { key: 'wind:2', timestamp: 3, value: 24 },
  { key: 'wind:3', timestamp: 3, value: 8 },
  { key: 'wind:4', timestamp: 3, value: 18 }
]);
console.log(res43); // >>> [3, 3, 3, 3]

// The result pairs contain the timestamp and the maximum sample value
// for the country at that timestamp.
const res44 = await client.ts.mRangeGroupBy(
  '-', '+', ['country=(us,uk)'],
  {label: 'country', REDUCE: TIME_SERIES_REDUCERS.MAX}
);
console.log(res44);
// >>> { "country=uk": { samples: [
//   { timestamp: 1, value: 18 },
//   { timestamp: 2, value: 21 },
//   { timestamp: 3, value: 24 }
// ] }, "country=us": { samples: [
//   { timestamp: 1, value: 20 },
//   { timestamp: 2, value: 25 },
//   { timestamp: 3, value: 18 }
// ] } }

// The result pairs contain the timestamp and the average sample value
// for the country at that timestamp.
const res45 = await client.ts.mRangeGroupBy(
  '-', '+', ['country=(us,uk)'],
  { label: 'country', REDUCE: TIME_SERIES_REDUCERS.AVG}
);
console.log(res45);
// >>> {
// "country=uk": {
//   samples: [{ timestamp: 1, value: 15 }, { timestamp: 2, value: 17.5 }, { timestamp: 3, value: 17 }]
// },
// "country=us": {
//   samples: [{ timestamp: 1, value: 12.5 }, { timestamp: 2, value: 14.5 }, { timestamp: 3, value: 13 }]
// }
// }

const res46 = await client.ts.create('hyg:1');
console.log(res46); // >>> OK

const res47 = await client.ts.create('hyg:compacted');
console.log(res47); // >>> OK

const res48 = await client.ts.createRule('hyg:1', 'hyg:compacted', TIME_SERIES_AGGREGATION_TYPE.MIN, 3);
console.log(res48); // >>> OK

const res49 = await client.ts.info('hyg:1');
console.log(res49.rules);
// >>> [{ aggregationType: 'MIN', key: 'hyg:compacted', timeBucket: 3}]

const res50 = await client.ts.info('hyg:compacted');
console.log(res50.sourceKey); // >>> 'hyg:1'

const res51 = await client.ts.mAdd([
  { key: 'hyg:1', timestamp: 0, value: 75 },
  { key: 'hyg:1', timestamp: 1, value: 77 },
  { key: 'hyg:1', timestamp: 2, value: 78 }
]);
console.log(res51); // >>> [0, 1, 2]

const res52 = await client.ts.range('hyg:compacted', '-', '+');
console.log(res52); // >>> []

const res53 = await client.ts.add('hyg:1', 3, 79);
console.log(res53); // >>> 3

const res54 = await client.ts.range('hyg:compacted', '-', '+');
console.log(res54); // >>> [{ timestamp: 0, value: 75 }]

const res55 = await client.ts.info('thermometer:1');
console.log(res55.totalSamples); // >>> 2
console.log(res55.firstTimestamp); // >>> 1
console.log(res55.lastTimestamp); // >>> 2

const res56 = await client.ts.add('thermometer:1', 3, 9.7);
console.log(res56); // >>> 3

const res57 = await client.ts.info('thermometer:1');
console.log(res57.totalSamples); // >>> 3
console.log(res57.firstTimestamp); // >>> 1
console.log(res57.lastTimestamp); // >>> 3

const res58 = await client.ts.del('thermometer:1', 1, 2);
console.log(res58); // >>> 2

const res59 = await client.ts.info('thermometer:1');
console.log(res59.totalSamples); // >>> 1
console.log(res59.firstTimestamp); // >>> 3
console.log(res59.lastTimestamp); // >>> 3

const res60 = await client.ts.del('thermometer:1', 3, 3);
console.log(res60); // >>> 1

const res61 = await client.ts.info('thermometer:1');
console.log(res61.totalSamples); // >>> 0

await client.quit();

import redis.clients.jedis.UnifiedJedis;
import redis.clients.jedis.timeseries.*;
import redis.clients.jedis.timeseries.TSElement;

import java.util.*;

public class TimeSeriesTutorialExample {

    public void run() {
        UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");

        String res1 = jedis.tsCreate("thermometer:1");
        System.out.println(res1); // >>> OK

        String res2 = jedis.type("thermometer:1");
        System.out.println(res2); // >>> TSDB-TYPE

        TSInfo res3 = jedis.tsInfo("thermometer:1");
        System.out.println(res3.getProperty("totalSamples")); // >>> 0

        long res4 = jedis.tsAdd("thermometer:2", 1L, 10.8, 
            TSCreateParams.createParams().retention(100));
        System.out.println(res4); // >>> 1

        TSInfo res5 = jedis.tsInfo("thermometer:2");
        System.out.println(res5.getProperty("retentionTime")); // >>> 100

        Map<String, String> labels = new HashMap<>();
        labels.put("location", "UK");
        labels.put("type", "Mercury");
        
        long res6 = jedis.tsAdd("thermometer:3", 1L, 10.4,
            TSCreateParams.createParams().labels(labels));
        System.out.println(res6); // >>> 1

        TSInfo res7 = jedis.tsInfo("thermometer:3");
        System.out.println("Labels: " + res7.getLabels());
        // >>> Labels: {location=UK, type=Mercury}

        List<Long> res8 = jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("thermometer:1", new TSElement(1L, 9.2)),
            new AbstractMap.SimpleEntry<>("thermometer:1", new TSElement(2L, 9.9)),
            new AbstractMap.SimpleEntry<>("thermometer:2", new TSElement(2L, 10.3))
        );
        System.out.println(res8); // >>> [1, 2, 2]

        // The last recorded temperature for thermometer:2
        // was 10.3 at time 2.
        TSElement res9 = jedis.tsGet("thermometer:2");
        System.out.println("(" + res9.getTimestamp() + ", " + res9.getValue() + ")");
        // >>> (2, 10.3)

        // Add 5 data points to a time series named "rg:1"
        String res10 = jedis.tsCreate("rg:1");
        System.out.println(res10); // >>> OK

        List<Long> res11 = jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("rg:1", new TSElement(0L, 18.0)),
            new AbstractMap.SimpleEntry<>("rg:1", new TSElement(1L, 14.0)),
            new AbstractMap.SimpleEntry<>("rg:1", new TSElement(2L, 22.0)),
            new AbstractMap.SimpleEntry<>("rg:1", new TSElement(3L, 18.0)),
            new AbstractMap.SimpleEntry<>("rg:1", new TSElement(4L, 24.0))
        );
        System.out.println(res11); // >>> [0, 1, 2, 3, 4]

        // Retrieve all the data points in ascending order
        List<TSElement> res12 = jedis.tsRange("rg:1", 0L, 4L);
        System.out.println(res12);
        // >>> [(0:18.0), (1:14.0), (2:22.0), (3:18.0), (4:24.0)]

        // Retrieve data points up to time 1 (inclusive)
        List<TSElement> res13 = jedis.tsRange("rg:1", 0L, 1L);
        System.out.println(res13);
        // >>> [(0:18.0), (1:14.0)]

        // Retrieve data points from time 3 onwards
        List<TSElement> res14 = jedis.tsRange("rg:1", 3L, 4L);
        System.out.println(res14);
        // >>> [(3:18.0), (4:24.0)]

        // Retrieve all the data points in descending order
        List<TSElement> res15 = jedis.tsRevRange("rg:1", 0L, 4L);
        System.out.println(res15);
        // >>> [(4:24.0), (3:18.0), (2:22.0), (1:14.0), (0:18.0)]

        // Retrieve data points up to time 1 (inclusive), in descending order
        List<TSElement> res16 = jedis.tsRevRange("rg:1", 0L, 1L);
        System.out.println(res16);
        // >>> [(1:14.0), (0:18.0)]

        List<TSElement> res17 = jedis.tsRange("rg:1",  
            TSRangeParams.rangeParams()
                .fromTimestamp(0L)
                .toTimestamp(4L)
                .filterByTS(0L, 2L, 4L)
        );
        System.out.println(res17);
        // >>> [(0:18.0), (2:22.0), (4:24.0)]

        List<TSElement> res18 = jedis.tsRevRange("rg:1",
            TSRangeParams.rangeParams()
                .fromTimestamp(0L)
                .toTimestamp(4L)
                .filterByTS(0L, 2L, 4L)
                .filterByValues(20.0, 25.0)
        );
        System.out.println(res18);
        // >>> [(4:24.0), (2:22.0)]

        List<TSElement> res19 = jedis.tsRevRange("rg:1",
            TSRangeParams.rangeParams()
                .fromTimestamp(0L)
                .toTimestamp(4L)
                .filterByTS(0L, 2L, 4L)
                .filterByValues(22.0, 22.0)
                .count(1)
        );
        System.out.println(res19);
        // >>> [(2:22.0)]

        // Create three new "rg:" time series (two in the US
        // and one in the UK, with different units) and add some
        // data points.
        Map<String, String> usLabels1 = new HashMap<>();
        usLabels1.put("location", "us");
        usLabels1.put("unit", "cm");
        
        Map<String, String> usLabels2 = new HashMap<>();
        usLabels2.put("location", "us");
        usLabels2.put("unit", "in");
        
        Map<String, String> ukLabels = new HashMap<>();
        ukLabels.put("location", "uk");
        ukLabels.put("unit", "mm");

        String res20 = jedis.tsCreate("rg:2",
            TSCreateParams.createParams().labels(usLabels1));
        System.out.println(res20); // >>> OK

        String res21 = jedis.tsCreate("rg:3",
            TSCreateParams.createParams().labels(usLabels2));
        System.out.println(res21); // >>> OK

        String res22 = jedis.tsCreate("rg:4",
            TSCreateParams.createParams().labels(ukLabels));
        System.out.println(res22); // >>> OK

        List<Long> res23 = jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("rg:2", new TSElement(0L, 1.8)),
            new AbstractMap.SimpleEntry<>("rg:3", new TSElement(0L, 0.9)),
            new AbstractMap.SimpleEntry<>("rg:4", new TSElement(0L, 25.0))
        );
        System.out.println(res23); // >>> [0, 0, 0]

        List<Long> res24 = jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("rg:2", new TSElement(1L, 2.1)),
            new AbstractMap.SimpleEntry<>("rg:3", new TSElement(1L, 0.77)),
            new AbstractMap.SimpleEntry<>("rg:4", new TSElement(1L, 18.0))
        );
        System.out.println(res24); // >>> [1, 1, 1]

        List<Long> res25 = jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("rg:2", new TSElement(2L, 2.3)),
            new AbstractMap.SimpleEntry<>("rg:3", new TSElement(2L, 1.1)),
            new AbstractMap.SimpleEntry<>("rg:4", new TSElement(2L, 21.0))
        );
        System.out.println(res25); // >>> [2, 2, 2]
        
        List<Long> res26 = jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("rg:2", new TSElement(3L, 1.9)),
            new AbstractMap.SimpleEntry<>("rg:3", new TSElement(3L, 0.81)),
            new AbstractMap.SimpleEntry<>("rg:4", new TSElement(3L, 19.0))
        );
        System.out.println(res26); // >>> [3, 3, 3]

        List<Long> res27 = jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("rg:2", new TSElement(4L, 1.78)),
            new AbstractMap.SimpleEntry<>("rg:3", new TSElement(4L, 0.74)),
            new AbstractMap.SimpleEntry<>("rg:4", new TSElement(4L, 23.0))
        );
        System.out.println(res27); // >>> [4, 4, 4]

        // Retrieve the last data point from each US time series.
        Map<String, TSMGetElement> res28 = jedis.tsMGet(
            TSMGetParams.multiGetParams().latest(),
             "location=us"
        );
        System.out.println(res28);
        // >>> {rg:2=TSMGetElement{key=rg:2, labels={}, element=(4:1.78)}...

        // Retrieve the same data points, but include the `unit`
        // label in the results.
        Map<String, TSMGetElement> res29 = jedis.tsMGet(
            TSMGetParams.multiGetParams().selectedLabels("unit"), 
            "location=us"
        );
        System.out.println(res29);
        // >>> {rg:2=TSMGetElement{key=rg:2, labels={unit=cm}, element=(4:1.78)}...

        // Retrieve data points up to time 2 (inclusive) from all
        // time series that use millimeters as the unit. Include all
        // labels in the results.
        Map<String, TSMRangeElements> res30 = jedis.tsMRange(
            TSMRangeParams.multiRangeParams(0L, 2L)
                .withLabels()
                .filter("unit=mm")
        );
        System.out.println(res30);
        // >>> {rg:4=TSMRangeElements{key=rg:4, labels={location=uk, unit=mm}, value=[(0:25.0), (1:18.0), (2:21.0)]}}

        // Retrieve data points from time 1 to time 3 (inclusive) from
        // all time series that use centimeters or millimeters as the unit,
        // but only return the `location` label. Return the results
        // in descending order of timestamp.
        Map<String, TSMRangeElements> res31 = jedis.tsMRevRange(
            TSMRangeParams.multiRangeParams(1L, 3L)
                .selectedLabels("location")
                .filter("unit=(cm,mm)")
        );
        System.out.println(res31);
        // >>> {rg:2=TSMRangeElements{key=rg:2, labels={location=us, unit=cm}, value=[(1:2.1)...

        List<TSElement> res32 = jedis.tsRange("rg:2",
            TSRangeParams.rangeParams()
                .fromTimestamp(0L)
                .toTimestamp(4L)
                .aggregation(AggregationType.AVG, 2)
        );
        System.out.println(res32);
        // >>> [(0:1.9500000000000002), (2:2.0999999999999996), (4:1.78)]

        String res33 = jedis.tsCreate("sensor3");
        System.out.println(res33); // >>> OK

        List<Long> res34 = jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("sensor3", new TSElement(10L, 1000.0)),
            new AbstractMap.SimpleEntry<>("sensor3", new TSElement(20L, 2000.0)),
            new AbstractMap.SimpleEntry<>("sensor3", new TSElement(30L, 3000.0)),
            new AbstractMap.SimpleEntry<>("sensor3", new TSElement(40L, 4000.0)),
            new AbstractMap.SimpleEntry<>("sensor3", new TSElement(50L, 5000.0)),
            new AbstractMap.SimpleEntry<>("sensor3", new TSElement(60L, 6000.0)),
            new AbstractMap.SimpleEntry<>("sensor3", new TSElement(70L, 7000.0))
        );
        System.out.println(res34); // >>> [10, 20, 30, 40, 50, 60, 70]

        List<TSElement> res35 = jedis.tsRange("sensor3",
            TSRangeParams.rangeParams()
                .fromTimestamp(10L)
                .toTimestamp(70L)
                .aggregation(AggregationType.MIN, 25)
        );
        System.out.println(res35);
        // >>> [(0:1000.0), (25:3000.0), (50:5000.0)]

        List<TSElement> res36 = jedis.tsRange("sensor3",
            TSRangeParams.rangeParams()
                .fromTimestamp(10L)
                .toTimestamp(70L)
                .aggregation(AggregationType.MIN, 25)
                .alignStart()
        );
        System.out.println(res36);
        // >>> [(10:1000.0), (35:4000.0), (60:6000.0)]

        Map<String, String> ukCountry = new HashMap<>();
        ukCountry.put("country", "uk");
        
        Map<String, String> usCountry = new HashMap<>();
        usCountry.put("country", "us");

        jedis.tsCreate("wind:1", TSCreateParams.createParams().labels(ukCountry));
        jedis.tsCreate("wind:2", TSCreateParams.createParams().labels(ukCountry));
        jedis.tsCreate("wind:3", TSCreateParams.createParams().labels(usCountry));
        jedis.tsCreate("wind:4", TSCreateParams.createParams().labels(usCountry));

        jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("wind:1", new TSElement(0L, 10.0)),
            new AbstractMap.SimpleEntry<>("wind:2", new TSElement(0L, 12.0)),
            new AbstractMap.SimpleEntry<>("wind:3", new TSElement(0L, 8.0)),
            new AbstractMap.SimpleEntry<>("wind:4", new TSElement(0L, 15.0))
        );

        jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("wind:1", new TSElement(1L, 11.0)),
            new AbstractMap.SimpleEntry<>("wind:2", new TSElement(1L, 13.0)),
            new AbstractMap.SimpleEntry<>("wind:3", new TSElement(1L, 9.0)),
            new AbstractMap.SimpleEntry<>("wind:4", new TSElement(1L, 16.0))
        );

        jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("wind:1", new TSElement(2L, 9.0)),
            new AbstractMap.SimpleEntry<>("wind:2", new TSElement(2L, 11.0)),
            new AbstractMap.SimpleEntry<>("wind:3", new TSElement(2L, 7.0)),
            new AbstractMap.SimpleEntry<>("wind:4", new TSElement(2L, 14.0))
        );

        jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("wind:1", new TSElement(3L, 12.0)),
            new AbstractMap.SimpleEntry<>("wind:2", new TSElement(3L, 14.0)),
            new AbstractMap.SimpleEntry<>("wind:3", new TSElement(3L, 10.0)),
            new AbstractMap.SimpleEntry<>("wind:4", new TSElement(3L, 17.0))
        );

        jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("wind:1", new TSElement(4L, 8.0)),
            new AbstractMap.SimpleEntry<>("wind:2", new TSElement(4L, 10.0)),
            new AbstractMap.SimpleEntry<>("wind:3", new TSElement(4L, 6.0)),
            new AbstractMap.SimpleEntry<>("wind:4", new TSElement(4L, 13.0))
        );

        // Group by country with max reduction
        Map<String, TSMRangeElements> res44 = jedis.tsMRange(
            TSMRangeParams.multiRangeParams(0L, 4L)
                .filter("country=(us,uk)")
                .groupBy("country", "max"));
        System.out.println(res44);
        // >>> {country=uk=TSMRangeElements{key=country=uk, labels={}, value=[(0:12.0)...

        // Group by country with avg reduction
        Map<String, TSMRangeElements> res45 = jedis.tsMRange(
            TSMRangeParams.multiRangeParams(0L, 4L)
                .filter("country=(us,uk)")
                .groupBy("country", "avg"));
        System.out.println(res45);
        // >>> {country=uk=TSMRangeElements{key=country=uk, labels={}, value=[(0:11.0)...

        String res46 = jedis.tsCreate("hyg:1");
        System.out.println(res46); // >>> OK

        String res47 = jedis.tsCreate("hyg:compacted");
        System.out.println(res47); // >>> OK

        String res48 = jedis.tsCreateRule("hyg:1", "hyg:compacted", AggregationType.MIN, 3);
        System.out.println(res48); // >>> OK

        TSInfo res49 = jedis.tsInfo("hyg:1");
        System.out.println("Rules: " + res49.getProperty("rules"));
        // >>> Rules: [{compactionKey=hyg:compacted, bucketDuration=3, aggregationType=MIN, alignmentTimestamp=0}]

        TSInfo res50 = jedis.tsInfo("hyg:compacted");
        System.out.println("Source key: " + res50.getProperty("sourceKey"));
        // >>> Source key: hyg:1

        List<Long> res51 = jedis.tsMAdd(
            new AbstractMap.SimpleEntry<>("hyg:1", new TSElement(0L, 75.0)),
            new AbstractMap.SimpleEntry<>("hyg:1", new TSElement(1L, 77.0)),
            new AbstractMap.SimpleEntry<>("hyg:1", new TSElement(2L, 78.0))
        );
        System.out.println(res51); // >>> [0, 1, 2]

        List<TSElement> res52 = jedis.tsRange("hyg:compacted", 0L, 10L);
        System.out.println(res52); // >>> []

        long res53 = jedis.tsAdd("hyg:1", 3L, 79.0);
        System.out.println(res53); // >>> 3

        List<TSElement> res54 = jedis.tsRange("hyg:compacted", 0L, 10L);
        System.out.println(res54); // >>> [(0:75.0)]

        TSInfo res55 = jedis.tsInfo("thermometer:1");
        System.out.println(res55.getProperty("totalSamples")); // >>> 2
        System.out.println(res55.getProperty("firstTimestamp")); // >>> 1
        System.out.println(res55.getProperty("lastTimestamp")); // >>> 2

        long res56 = jedis.tsAdd("thermometer:1", 3L, 9.7);
        System.out.println(res56); // >>> 3

        TSInfo res57 = jedis.tsInfo("thermometer:1");
        System.out.println(res57.getProperty("totalSamples")); // >>> 3

        long res58 = jedis.tsDel("thermometer:1", 1L, 2L);
        System.out.println(res58); // >>> 2

        TSInfo res59 = jedis.tsInfo("thermometer:1");
        System.out.println(res59.getProperty("totalSamples")); // >>> 1

        long res60 = jedis.tsDel("thermometer:1", 3L, 3L);
        System.out.println(res60); // >>> 1

        TSInfo res61 = jedis.tsInfo("thermometer:1");
        System.out.println(res61.getProperty("totalSamples")); // >>> 0

        jedis.close();
    }
}