Skip to content

Commit 5d147d9

Browse files
andre-cc-natzkaandre-cc-natzka
committed
Fix tests
1 parent cd08e71 commit 5d147d9

File tree

5 files changed

+0
-787
lines changed

5 files changed

+0
-787
lines changed

‎datafusion/core/tests/sql/aggregates.rs‎

Lines changed: 0 additions & 86 deletions
Original file line numberDiff line numberDiff line change
@@ -1592,92 +1592,6 @@ async fn aggregate_times_max() -> Result<()> {
15921592
Ok(())
15931593
}
15941594

1595-
#[tokio::test]
1596-
async fn aggregate_times_sum() -> Result<()> {
1597-
let ctx = SessionContext::new();
1598-
ctx.register_table("t", table_with_times()).unwrap();
1599-
1600-
let results = plan_and_collect(
1601-
&ctx,
1602-
"SELECT sum(nanos), sum(micros), sum(millis), sum(secs) FROM t",
1603-
)
1604-
.await
1605-
.unwrap_err();
1606-
1607-
assert_eq!(results.to_string(), "Error during planning: The function Sum does not support inputs of type Time64(Nanosecond).");
1608-
1609-
Ok(())
1610-
}
1611-
1612-
#[tokio::test]
1613-
async fn aggregate_times_count() -> Result<()> {
1614-
let ctx = SessionContext::new();
1615-
ctx.register_table("t", table_with_times()).unwrap();
1616-
1617-
let results = execute_to_batches(
1618-
&ctx,
1619-
"SELECT count(nanos), count(micros), count(millis), count(secs) FROM t",
1620-
)
1621-
.await;
1622-
1623-
let expected = vec![
1624-
"+----------------+-----------------+-----------------+---------------+",
1625-
"| COUNT(t.nanos) | COUNT(t.micros) | COUNT(t.millis) | COUNT(t.secs) |",
1626-
"+----------------+-----------------+-----------------+---------------+",
1627-
"| 4 | 4 | 4 | 4 |",
1628-
"+----------------+-----------------+-----------------+---------------+",
1629-
];
1630-
assert_batches_sorted_eq!(expected, &results);
1631-
1632-
Ok(())
1633-
}
1634-
1635-
#[tokio::test]
1636-
async fn aggregate_times_min() -> Result<()> {
1637-
let ctx = SessionContext::new();
1638-
ctx.register_table("t", table_with_times()).unwrap();
1639-
1640-
let results = execute_to_batches(
1641-
&ctx,
1642-
"SELECT min(nanos), min(micros), min(millis), min(secs) FROM t",
1643-
)
1644-
.await;
1645-
1646-
let expected = vec![
1647-
"+--------------------+-----------------+---------------+-------------+",
1648-
"| MIN(t.nanos) | MIN(t.micros) | MIN(t.millis) | MIN(t.secs) |",
1649-
"+--------------------+-----------------+---------------+-------------+",
1650-
"| 18:06:30.243620451 | 18:06:30.243620 | 18:06:30.243 | 18:06:30 |",
1651-
"+--------------------+-----------------+---------------+-------------+",
1652-
];
1653-
assert_batches_sorted_eq!(expected, &results);
1654-
1655-
Ok(())
1656-
}
1657-
1658-
#[tokio::test]
1659-
async fn aggregate_times_max() -> Result<()> {
1660-
let ctx = SessionContext::new();
1661-
ctx.register_table("t", table_with_times()).unwrap();
1662-
1663-
let results = execute_to_batches(
1664-
&ctx,
1665-
"SELECT max(nanos), max(micros), max(millis), max(secs) FROM t",
1666-
)
1667-
.await;
1668-
1669-
let expected = vec![
1670-
"+--------------------+-----------------+---------------+-------------+",
1671-
"| MAX(t.nanos) | MAX(t.micros) | MAX(t.millis) | MAX(t.secs) |",
1672-
"+--------------------+-----------------+---------------+-------------+",
1673-
"| 21:06:28.247821084 | 21:06:28.247821 | 21:06:28.247 | 21:06:28 |",
1674-
"+--------------------+-----------------+---------------+-------------+",
1675-
];
1676-
assert_batches_sorted_eq!(expected, &results);
1677-
1678-
Ok(())
1679-
}
1680-
16811595
#[tokio::test]
16821596
async fn aggregate_timestamps_avg() -> Result<()> {
16831597
let ctx = SessionContext::new();

‎datafusion/core/tests/sql/group_by.rs‎

Lines changed: 0 additions & 180 deletions
Original file line numberDiff line numberDiff line change
@@ -665,186 +665,6 @@ async fn csv_group_by_time64nanosecond() -> Result<()> {
665665
Ok(())
666666
}
667667

668-
#[tokio::test]
669-
async fn csv_group_by_time32second() -> Result<()> {
670-
let ctx = SessionContext::new();
671-
let schema = Arc::new(Schema::new(vec![
672-
Field::new("time", DataType::Time32(TimeUnit::Second), false),
673-
Field::new("cnt", DataType::Int32, false),
674-
]));
675-
let data = RecordBatch::try_new(
676-
schema.clone(),
677-
vec![
678-
Arc::new(Time32SecondArray::from(vec![
679-
Some(5_000),
680-
Some(5_000),
681-
Some(5_500),
682-
Some(5_500),
683-
Some(5_900),
684-
Some(5_900),
685-
])),
686-
Arc::new(Int32Array::from(vec![
687-
Some(1),
688-
Some(1),
689-
Some(1),
690-
Some(2),
691-
Some(1),
692-
Some(3),
693-
])),
694-
],
695-
)?;
696-
697-
ctx.register_batch("times", data)?;
698-
let sql = "SELECT SUM(cnt) FROM times GROUP BY time";
699-
let actual = execute_to_batches(&ctx, sql).await;
700-
let expected = vec![
701-
"+----------------+",
702-
"| SUM(times.cnt) |",
703-
"+----------------+",
704-
"| 2 |",
705-
"| 3 |",
706-
"| 4 |",
707-
"+----------------+",
708-
];
709-
assert_batches_sorted_eq!(expected, &actual);
710-
Ok(())
711-
}
712-
713-
#[tokio::test]
714-
async fn csv_group_by_time32millisecond() -> Result<()> {
715-
let ctx = SessionContext::new();
716-
let schema = Arc::new(Schema::new(vec![
717-
Field::new("time", DataType::Time32(TimeUnit::Millisecond), false),
718-
Field::new("cnt", DataType::Int32, false),
719-
]));
720-
let data = RecordBatch::try_new(
721-
schema.clone(),
722-
vec![
723-
Arc::new(Time32MillisecondArray::from(vec![
724-
Some(5_000_000),
725-
Some(5_000_000),
726-
Some(5_500_000),
727-
Some(5_500_000),
728-
Some(5_900_000),
729-
Some(5_900_000),
730-
])),
731-
Arc::new(Int32Array::from(vec![
732-
Some(1),
733-
Some(1),
734-
Some(1),
735-
Some(2),
736-
Some(1),
737-
Some(3),
738-
])),
739-
],
740-
)?;
741-
742-
ctx.register_batch("times", data)?;
743-
let sql = "SELECT SUM(cnt) FROM times GROUP BY time";
744-
let actual = execute_to_batches(&ctx, sql).await;
745-
let expected = vec![
746-
"+----------------+",
747-
"| SUM(times.cnt) |",
748-
"+----------------+",
749-
"| 2 |",
750-
"| 3 |",
751-
"| 4 |",
752-
"+----------------+",
753-
];
754-
assert_batches_sorted_eq!(expected, &actual);
755-
Ok(())
756-
}
757-
758-
#[tokio::test]
759-
async fn csv_group_by_time64microsecond() -> Result<()> {
760-
let ctx = SessionContext::new();
761-
let schema = Arc::new(Schema::new(vec![
762-
Field::new("time", DataType::Time64(TimeUnit::Microsecond), false),
763-
Field::new("cnt", DataType::Int64, false),
764-
]));
765-
let data = RecordBatch::try_new(
766-
schema.clone(),
767-
vec![
768-
Arc::new(Time64MicrosecondArray::from(vec![
769-
Some(5_000_000_000),
770-
Some(5_000_000_000),
771-
Some(5_500_000_000),
772-
Some(5_500_000_000),
773-
Some(5_900_000_000),
774-
Some(5_900_000_000),
775-
])),
776-
Arc::new(Int64Array::from(vec![
777-
Some(1),
778-
Some(1),
779-
Some(1),
780-
Some(2),
781-
Some(1),
782-
Some(3),
783-
])),
784-
],
785-
)?;
786-
787-
ctx.register_batch("times", data)?;
788-
let sql = "SELECT SUM(cnt) FROM times GROUP BY time";
789-
let actual = execute_to_batches(&ctx, sql).await;
790-
let expected = vec![
791-
"+----------------+",
792-
"| SUM(times.cnt) |",
793-
"+----------------+",
794-
"| 2 |",
795-
"| 3 |",
796-
"| 4 |",
797-
"+----------------+",
798-
];
799-
assert_batches_sorted_eq!(expected, &actual);
800-
Ok(())
801-
}
802-
803-
#[tokio::test]
804-
async fn csv_group_by_time64nanosecond() -> Result<()> {
805-
let ctx = SessionContext::new();
806-
let schema = Arc::new(Schema::new(vec![
807-
Field::new("time", DataType::Time64(TimeUnit::Nanosecond), false),
808-
Field::new("cnt", DataType::Int64, false),
809-
]));
810-
let data = RecordBatch::try_new(
811-
schema.clone(),
812-
vec![
813-
Arc::new(Time64NanosecondArray::from(vec![
814-
Some(5_000_000_000_000),
815-
Some(5_000_000_000_000),
816-
Some(5_500_000_000_000),
817-
Some(5_500_000_000_000),
818-
Some(5_900_000_000_000),
819-
Some(5_900_000_000_000),
820-
])),
821-
Arc::new(Int64Array::from(vec![
822-
Some(1),
823-
Some(1),
824-
Some(1),
825-
Some(2),
826-
Some(1),
827-
Some(3),
828-
])),
829-
],
830-
)?;
831-
832-
ctx.register_batch("times", data)?;
833-
let sql = "SELECT SUM(cnt) FROM times GROUP BY time";
834-
let actual = execute_to_batches(&ctx, sql).await;
835-
let expected = vec![
836-
"+----------------+",
837-
"| SUM(times.cnt) |",
838-
"+----------------+",
839-
"| 2 |",
840-
"| 3 |",
841-
"| 4 |",
842-
"+----------------+",
843-
];
844-
assert_batches_sorted_eq!(expected, &actual);
845-
Ok(())
846-
}
847-
848668
#[tokio::test]
849669
async fn group_by_date_trunc() -> Result<()> {
850670
let tmp_dir = TempDir::new()?;

‎datafusion/core/tests/sql/mod.rs‎

Lines changed: 0 additions & 93 deletions
Original file line numberDiff line numberDiff line change
@@ -1277,99 +1277,6 @@ pub fn make_times() -> RecordBatch {
12771277
.unwrap()
12781278
}
12791279

1280-
/// Return a new table provider containing all of the supported timestamp types
1281-
pub fn table_with_times() -> Arc<dyn TableProvider> {
1282-
let batch = make_times();
1283-
let schema = batch.schema();
1284-
let partitions = vec![vec![batch]];
1285-
Arc::new(MemTable::try_new(schema, partitions).unwrap())
1286-
}
1287-
1288-
/// Return record batch with all of the supported time types
1289-
/// values
1290-
///
1291-
/// Columns are named:
1292-
/// "nanos" --> Time64NanosecondArray
1293-
/// "micros" --> Time64MicrosecondArray
1294-
/// "millis" --> Time32MillisecondArray
1295-
/// "secs" --> Time32SecondArray
1296-
/// "names" --> StringArray
1297-
pub fn make_times() -> RecordBatch {
1298-
let ts_strings = vec![
1299-
Some("18:06:30.243620451"),
1300-
Some("20:08:28.161121654"),
1301-
Some("19:11:04.156423842"),
1302-
Some("21:06:28.247821084"),
1303-
];
1304-
1305-
let ts_nanos = ts_strings
1306-
.into_iter()
1307-
.map(|t| {
1308-
t.map(|t| {
1309-
let integer_sec = t
1310-
.parse::<chrono::NaiveTime>()
1311-
.unwrap()
1312-
.num_seconds_from_midnight() as i64;
1313-
let extra_nano =
1314-
t.parse::<chrono::NaiveTime>().unwrap().nanosecond() as i64;
1315-
// Total time in nanoseconds given by integer number of seconds multiplied by 10^9
1316-
// plus number of nanoseconds corresponding to the extra fraction of second
1317-
integer_sec * 1_000_000_000 + extra_nano
1318-
})
1319-
})
1320-
.collect::<Vec<_>>();
1321-
1322-
let ts_micros = ts_nanos
1323-
.iter()
1324-
.map(|t| t.as_ref().map(|ts_nanos| ts_nanos / 1000))
1325-
.collect::<Vec<_>>();
1326-
1327-
let ts_millis = ts_nanos
1328-
.iter()
1329-
.map(|t| t.as_ref().map(|ts_nanos| { ts_nanos / 1000000 } as i32))
1330-
.collect::<Vec<_>>();
1331-
1332-
let ts_secs = ts_nanos
1333-
.iter()
1334-
.map(|t| t.as_ref().map(|ts_nanos| { ts_nanos / 1000000000 } as i32))
1335-
.collect::<Vec<_>>();
1336-
1337-
let names = ts_nanos
1338-
.iter()
1339-
.enumerate()
1340-
.map(|(i, _)| format!("Row {}", i))
1341-
.collect::<Vec<_>>();
1342-
1343-
let arr_nanos = Time64NanosecondArray::from(ts_nanos);
1344-
let arr_micros = Time64MicrosecondArray::from(ts_micros);
1345-
let arr_millis = Time32MillisecondArray::from(ts_millis);
1346-
let arr_secs = Time32SecondArray::from(ts_secs);
1347-
1348-
let names = names.iter().map(|s| s.as_str()).collect::<Vec<_>>();
1349-
let arr_names = StringArray::from(names);
1350-
1351-
let schema = Schema::new(vec![
1352-
Field::new("nanos", arr_nanos.data_type().clone(), true),
1353-
Field::new("micros", arr_micros.data_type().clone(), true),
1354-
Field::new("millis", arr_millis.data_type().clone(), true),
1355-
Field::new("secs", arr_secs.data_type().clone(), true),
1356-
Field::new("name", arr_names.data_type().clone(), true),
1357-
]);
1358-
let schema = Arc::new(schema);
1359-
1360-
RecordBatch::try_new(
1361-
schema,
1362-
vec![
1363-
Arc::new(arr_nanos),
1364-
Arc::new(arr_micros),
1365-
Arc::new(arr_millis),
1366-
Arc::new(arr_secs),
1367-
Arc::new(arr_names),
1368-
],
1369-
)
1370-
.unwrap()
1371-
}
1372-
13731280
#[tokio::test]
13741281
async fn nyc() -> Result<()> {
13751282
// schema for nyxtaxi csv files

0 commit comments

Comments
 (0)