816 lines
15 KiB
Rust
816 lines
15 KiB
Rust
mod parse;
|
|
use parse::Parse;
|
|
mod helpers;
|
|
use crate::helpers::Test;
|
|
use helpers::new_ds;
|
|
use helpers::skip_ok;
|
|
use surrealdb::dbs::Session;
|
|
use surrealdb::err::Error;
|
|
use surrealdb::sql::Value;
|
|
|
|
#[tokio::test]
|
|
async fn select_aggregate() -> Result<(), Error> {
|
|
let sql = "
|
|
CREATE temperature:1 SET country = 'GBP', time = d'2020-01-01T08:00:00Z';
|
|
CREATE temperature:2 SET country = 'GBP', time = d'2020-02-01T08:00:00Z';
|
|
CREATE temperature:3 SET country = 'GBP', time = d'2020-03-01T08:00:00Z';
|
|
CREATE temperature:4 SET country = 'GBP', time = d'2021-01-01T08:00:00Z';
|
|
CREATE temperature:5 SET country = 'GBP', time = d'2021-01-01T08:00:00Z';
|
|
CREATE temperature:6 SET country = 'EUR', time = d'2021-01-01T08:00:00Z';
|
|
CREATE temperature:7 SET country = 'USD', time = d'2021-01-01T08:00:00Z';
|
|
CREATE temperature:8 SET country = 'AUD', time = d'2021-01-01T08:00:00Z';
|
|
CREATE temperature:9 SET country = 'CHF', time = d'2023-01-01T08:00:00Z';
|
|
SELECT *, time::year(time) AS year FROM temperature;
|
|
SELECT count(), time::min(time) as min, time::max(time) as max, time::year(time) AS year, country FROM temperature GROUP BY country, year;
|
|
SELECT count(), time::min(time) as min, time::max(time) as max, time::year(time) AS year, country FROM temperature GROUP BY country, year EXPLAIN;
|
|
";
|
|
let dbs = new_ds().await?;
|
|
let ses = Session::owner().with_ns("test").with_db("test");
|
|
let res = &mut dbs.execute(sql, &ses, None).await?;
|
|
assert_eq!(res.len(), 12);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:1,
|
|
time: d'2020-01-01T08:00:00Z'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:2,
|
|
time: d'2020-02-01T08:00:00Z'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:3,
|
|
time: d'2020-03-01T08:00:00Z'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:4,
|
|
time: d'2021-01-01T08:00:00Z'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:5,
|
|
time: d'2021-01-01T08:00:00Z'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'EUR',
|
|
id: temperature:6,
|
|
time: d'2021-01-01T08:00:00Z'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'USD',
|
|
id: temperature:7,
|
|
time: d'2021-01-01T08:00:00Z'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'AUD',
|
|
id: temperature:8,
|
|
time: d'2021-01-01T08:00:00Z'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'CHF',
|
|
id: temperature:9,
|
|
time: d'2023-01-01T08:00:00Z'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:1,
|
|
time: d'2020-01-01T08:00:00Z',
|
|
year: 2020
|
|
},
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:2,
|
|
time: d'2020-02-01T08:00:00Z',
|
|
year: 2020
|
|
},
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:3,
|
|
time: d'2020-03-01T08:00:00Z',
|
|
year: 2020
|
|
},
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:4,
|
|
time: d'2021-01-01T08:00:00Z',
|
|
year: 2021
|
|
},
|
|
{
|
|
country: 'GBP',
|
|
id: temperature:5,
|
|
time: d'2021-01-01T08:00:00Z',
|
|
year: 2021
|
|
},
|
|
{
|
|
country: 'EUR',
|
|
id: temperature:6,
|
|
time: d'2021-01-01T08:00:00Z',
|
|
year: 2021
|
|
},
|
|
{
|
|
country: 'USD',
|
|
id: temperature:7,
|
|
time: d'2021-01-01T08:00:00Z',
|
|
year: 2021
|
|
},
|
|
{
|
|
country: 'AUD',
|
|
id: temperature:8,
|
|
time: d'2021-01-01T08:00:00Z',
|
|
year: 2021
|
|
},
|
|
{
|
|
country: 'CHF',
|
|
id: temperature:9,
|
|
time: d'2023-01-01T08:00:00Z',
|
|
year: 2023
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
count: 1,
|
|
country: 'AUD',
|
|
max: d'2021-01-01T08:00:00Z',
|
|
min: d'2021-01-01T08:00:00Z',
|
|
year: 2021
|
|
},
|
|
{
|
|
count: 1,
|
|
country: 'CHF',
|
|
max: d'2023-01-01T08:00:00Z',
|
|
min: d'2023-01-01T08:00:00Z',
|
|
year: 2023
|
|
},
|
|
{
|
|
count: 1,
|
|
country: 'EUR',
|
|
max: d'2021-01-01T08:00:00Z',
|
|
min: d'2021-01-01T08:00:00Z',
|
|
year: 2021
|
|
},
|
|
{
|
|
count: 3,
|
|
country: 'GBP',
|
|
max: d'2020-03-01T08:00:00Z',
|
|
min: d'2020-01-01T08:00:00Z',
|
|
year: 2020
|
|
},
|
|
{
|
|
count: 2,
|
|
country: 'GBP',
|
|
max: d'2021-01-01T08:00:00Z',
|
|
min: d'2021-01-01T08:00:00Z',
|
|
year: 2021
|
|
},
|
|
{
|
|
count: 1,
|
|
country: 'USD',
|
|
max: d'2021-01-01T08:00:00Z',
|
|
min: d'2021-01-01T08:00:00Z',
|
|
year: 2021
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
detail: {
|
|
table: 'temperature'
|
|
},
|
|
operation: 'Iterate Table'
|
|
},
|
|
{
|
|
detail: {
|
|
idioms: {
|
|
count: [
|
|
'count'
|
|
],
|
|
country: [
|
|
'first'
|
|
],
|
|
max: [
|
|
'time::max'
|
|
],
|
|
min: [
|
|
'time::min'
|
|
],
|
|
year: [
|
|
'array'
|
|
]
|
|
},
|
|
type: 'Group'
|
|
},
|
|
operation: 'Collector'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(format!("{tmp:#}"), format!("{val:#}"));
|
|
//
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn select_multi_aggregate() -> Result<(), Error> {
|
|
let sql = "
|
|
CREATE test:1 SET group = 1, one = 1.7, two = 2.4;
|
|
CREATE test:2 SET group = 1, one = 4.7, two = 3.9;
|
|
CREATE test:3 SET group = 2, one = 3.2, two = 9.7;
|
|
CREATE test:4 SET group = 2, one = 4.4, two = 3.0;
|
|
SELECT group, math::sum(one) AS one, math::sum(two) AS two, math::min(one) as min FROM test GROUP BY group;
|
|
SELECT group, math::sum(two) AS two, math::sum(one) AS one, math::max(two) as max, math::mean(one) as mean FROM test GROUP BY group;
|
|
SELECT group, math::sum(two) AS two, math::sum(one) AS one, math::max(two) as max, math::mean(one) as mean FROM test GROUP BY group EXPLAIN;
|
|
";
|
|
let dbs = new_ds().await?;
|
|
let ses = Session::owner().with_ns("test").with_db("test");
|
|
let res = &mut dbs.execute(sql, &ses, None).await?;
|
|
assert_eq!(res.len(), 7);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:1,
|
|
group: 1,
|
|
one: 1.7,
|
|
two: 2.4,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:2,
|
|
group: 1,
|
|
one: 4.7,
|
|
two: 3.9,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:3,
|
|
group: 2,
|
|
one: 3.2,
|
|
two: 9.7,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:4,
|
|
group: 2,
|
|
one: 4.4,
|
|
two: 3.0,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
group: 1,
|
|
min: 1.7,
|
|
one: 6.4,
|
|
two: 6.3
|
|
},
|
|
{
|
|
group: 2,
|
|
min: 3.2f,
|
|
one: 7.6000000000000005,
|
|
two: 12.7
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
group: 1,
|
|
max: 3.9,
|
|
mean: 3.2,
|
|
one: 6.4,
|
|
two: 6.3
|
|
},
|
|
{
|
|
group: 2,
|
|
max: 9.7,
|
|
mean: 3.8000000000000003,
|
|
one: 7.6000000000000005,
|
|
two: 12.7
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
detail: {
|
|
table: 'test'
|
|
},
|
|
operation: 'Iterate Table'
|
|
},
|
|
{
|
|
detail: {
|
|
idioms: {
|
|
group: [
|
|
'first'
|
|
],
|
|
max: [
|
|
'math::max'
|
|
],
|
|
mean: [
|
|
'math::mean'
|
|
],
|
|
one: [
|
|
'math::sum'
|
|
],
|
|
two: [
|
|
'math::sum'
|
|
]
|
|
},
|
|
type: 'Group'
|
|
},
|
|
operation: 'Collector'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(format!("{tmp:#}"), format!("{val:#}"));
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn select_multi_aggregate_composed() -> Result<(), Error> {
|
|
let sql = "
|
|
CREATE test:1 SET group = 1, one = 1.7, two = 2.4;
|
|
CREATE test:2 SET group = 1, one = 4.7, two = 3.9;
|
|
CREATE test:3 SET group = 2, one = 3.2, two = 9.7;
|
|
CREATE test:4 SET group = 2, one = 4.4, two = 3.0;
|
|
SELECT group, math::sum(math::floor(one)) AS one, math::sum(math::floor(two)) AS two FROM test GROUP BY group;
|
|
SELECT group, math::sum(math::round(one)) AS one, math::sum(math::round(two)) AS two FROM test GROUP BY group;
|
|
SELECT group, math::sum(math::ceil(one)) AS one, math::sum(math::ceil(two)) AS two FROM test GROUP BY group;
|
|
SELECT group, math::sum(math::ceil(one)) AS one, math::sum(math::ceil(two)) AS two FROM test GROUP BY group EXPLAIN;
|
|
";
|
|
let dbs = new_ds().await?;
|
|
let ses = Session::owner().with_ns("test").with_db("test");
|
|
let res = &mut dbs.execute(sql, &ses, None).await?;
|
|
assert_eq!(res.len(), 8);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:1,
|
|
group: 1,
|
|
one: 1.7,
|
|
two: 2.4,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:2,
|
|
group: 1,
|
|
one: 4.7,
|
|
two: 3.9,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:3,
|
|
group: 2,
|
|
one: 3.2,
|
|
two: 9.7,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:4,
|
|
group: 2,
|
|
one: 4.4,
|
|
two: 3.0,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
group: 1,
|
|
one: 5,
|
|
two: 5,
|
|
},
|
|
{
|
|
group: 2,
|
|
one: 7,
|
|
two: 12,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
group: 1,
|
|
one: 7,
|
|
two: 6,
|
|
},
|
|
{
|
|
group: 2,
|
|
one: 7,
|
|
two: 13,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
group: 1,
|
|
one: 7,
|
|
two: 7,
|
|
},
|
|
{
|
|
group: 2,
|
|
one: 9,
|
|
two: 13,
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
detail: {
|
|
table: 'test'
|
|
},
|
|
operation: 'Iterate Table'
|
|
},
|
|
{
|
|
detail: {
|
|
idioms: {
|
|
group: [
|
|
'first'
|
|
],
|
|
one: [
|
|
'math::sum'
|
|
],
|
|
two: [
|
|
'math::sum'
|
|
]
|
|
},
|
|
type: 'Group'
|
|
},
|
|
operation: 'Collector'
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(format!("{tmp:#}"), format!("{val:#}"));
|
|
//
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn select_array_group_group_by() -> Result<(), Error> {
|
|
let sql = "
|
|
CREATE test:1 SET user = 1, role = 1;
|
|
CREATE test:2 SET user = 1, role = 2;
|
|
CREATE test:3 SET user = 2, role = 1;
|
|
CREATE test:4 SET user = 2, role = 2;
|
|
SELECT user, array::group(role) FROM test GROUP BY user;
|
|
";
|
|
let dbs = new_ds().await?;
|
|
let ses = Session::owner().with_ns("test").with_db("test");
|
|
let res = &mut dbs.execute(sql, &ses, None).await?;
|
|
assert_eq!(res.len(), 5);
|
|
//
|
|
skip_ok(res, 4)?;
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
r#"[
|
|
{
|
|
"array::group": [
|
|
1,2
|
|
],
|
|
user: 1
|
|
},
|
|
{
|
|
"array::group": [
|
|
1,2
|
|
],
|
|
user: 2
|
|
}
|
|
]"#,
|
|
);
|
|
assert_eq!(format!("{tmp:#}"), format!("{val:#}"));
|
|
//
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn select_array_count_subquery_group_by() -> Result<(), Error> {
|
|
let sql = r#"
|
|
CREATE table CONTENT { bar: "hello", foo: "Man"};
|
|
CREATE table CONTENT { bar: "hello", foo: "World"};
|
|
CREATE table CONTENT { bar: "world"};
|
|
SELECT COUNT(foo != none) FROM table GROUP ALL EXPLAIN;
|
|
SELECT COUNT(foo != none) FROM table GROUP ALL;
|
|
"#;
|
|
let dbs = new_ds().await?;
|
|
let ses = Session::owner().with_ns("test").with_db("test");
|
|
let res = &mut dbs.execute(sql, &ses, None).await?;
|
|
assert_eq!(res.len(), 5);
|
|
//
|
|
skip_ok(res, 3)?;
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
r#"[
|
|
{
|
|
detail: {
|
|
table: 'table'
|
|
},
|
|
operation: 'Iterate Table'
|
|
},
|
|
{
|
|
detail: {
|
|
idioms: {
|
|
count: [
|
|
'count+func'
|
|
]
|
|
},
|
|
type: 'Group'
|
|
},
|
|
operation: 'Collector'
|
|
}
|
|
]"#,
|
|
);
|
|
assert_eq!(format!("{tmp:#}"), format!("{val:#}"));
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
r#"[
|
|
{
|
|
count: 2
|
|
}
|
|
]"#,
|
|
);
|
|
assert_eq!(format!("{tmp:#}"), format!("{val:#}"));
|
|
//
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn select_aggregate_mean_update() -> Result<(), Error> {
|
|
let sql = "
|
|
CREATE test:a SET a = 3;
|
|
DEFINE TABLE foo AS SELECT
|
|
math::mean(a) AS avg
|
|
FROM test
|
|
GROUP ALL;
|
|
|
|
UPDATE test:a SET a = 2;
|
|
|
|
SELECT avg FROM foo;
|
|
";
|
|
let dbs = new_ds().await?;
|
|
let ses = Session::owner().with_ns("test").with_db("test");
|
|
let res = &mut dbs.execute(sql, &ses, None).await?;
|
|
assert_eq!(res.len(), 4);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:a,
|
|
a: 3
|
|
}
|
|
]",
|
|
);
|
|
|
|
assert_eq!(tmp, val);
|
|
//
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse("None");
|
|
|
|
assert_eq!(tmp, val);
|
|
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
id: test:a,
|
|
a: 2
|
|
}
|
|
]",
|
|
);
|
|
|
|
assert_eq!(tmp, val);
|
|
|
|
let tmp = res.remove(0).result?;
|
|
let val = Value::parse(
|
|
"[
|
|
{
|
|
avg: 2
|
|
}
|
|
]",
|
|
);
|
|
assert_eq!(tmp, val);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn select_count_group_all() -> Result<(), Error> {
|
|
let sql = r#"
|
|
CREATE table CONTENT { bar: "hello", foo: "Man"};
|
|
CREATE table CONTENT { bar: "hello", foo: "World"};
|
|
CREATE table CONTENT { bar: "world"};
|
|
SELECT COUNT() FROM table GROUP ALL EXPLAIN;
|
|
SELECT COUNT() FROM table GROUP ALL;
|
|
SELECT COUNT() FROM table EXPLAIN;
|
|
SELECT COUNT() FROM table;
|
|
"#;
|
|
let mut t = Test::new(sql).await?;
|
|
t.expect_size(7)?;
|
|
//
|
|
t.skip_ok(3)?;
|
|
//
|
|
t.expect_val(
|
|
r#"[
|
|
{
|
|
detail: {
|
|
table: 'table'
|
|
},
|
|
operation: 'Iterate Table Keys'
|
|
},
|
|
{
|
|
detail: {
|
|
idioms: {
|
|
count: [
|
|
'count'
|
|
]
|
|
},
|
|
type: 'Group'
|
|
},
|
|
operation: 'Collector'
|
|
}
|
|
]"#,
|
|
)?;
|
|
//
|
|
t.expect_val(
|
|
r#"[
|
|
{
|
|
count: 3
|
|
}
|
|
]"#,
|
|
)?;
|
|
//
|
|
t.expect_val(
|
|
r#"[
|
|
{
|
|
detail: {
|
|
table: 'table'
|
|
},
|
|
operation: 'Iterate Table Keys'
|
|
},
|
|
{
|
|
detail: {
|
|
type: 'Memory'
|
|
},
|
|
operation: 'Collector'
|
|
}
|
|
]"#,
|
|
)?;
|
|
//
|
|
t.expect_val(
|
|
r#"[
|
|
{
|
|
count: 1
|
|
},
|
|
{
|
|
count: 1
|
|
},
|
|
{
|
|
count: 1
|
|
}
|
|
]"#,
|
|
)?;
|
|
Ok(())
|
|
}
|