use chdb_rust::connection::Connection;
#[test]
fn an_arrow_stream_binds_parameters() {
let mut conn = Connection::open_in_memory().expect("open");
let mut stream = conn
.query_stream_arrow_with_params(
"SELECT number FROM numbers({n:UInt64})",
[("n", "3")],
None,
)
.expect("stream");
let mut rows = 0usize;
while let Some(batch) = stream.next_batch().expect("batch") {
rows += batch.num_rows();
}
assert_eq!(rows, 3);
}
use arrow::array::RecordBatchReader;
use arrow::datatypes::DataType;
use chdb_rust::arrow_options::ArrowOptions;
#[test]
fn a_one_shot_query_returns_every_row() {
let conn = Connection::open_in_memory().expect("open");
let reader = conn
.query_arrow("SELECT number FROM numbers(1000)")
.expect("query_arrow");
let rows: usize = reader.map(|b| b.expect("batch").num_rows()).sum();
assert_eq!(rows, 1000);
}
#[test]
fn a_one_shot_reader_outlives_its_connection() {
let conn = Connection::open_in_memory().expect("open");
let reader = conn
.query_arrow("SELECT number FROM numbers(1000)")
.expect("query_arrow");
drop(conn);
let rows: usize = reader.map(|b| b.expect("batch").num_rows()).sum();
assert_eq!(rows, 1000);
}
#[test]
fn a_one_shot_query_matches_the_streamed_result() {
let mut conn = Connection::open_in_memory().expect("open");
let sql = "SELECT number, toString(number) AS s FROM numbers(500)";
let one_shot: usize = conn
.query_arrow(sql)
.expect("query_arrow")
.map(|b| b.expect("batch").num_rows())
.sum();
let mut stream = conn.query_stream_arrow(sql).expect("stream");
let mut streamed = 0usize;
while let Some(batch) = stream.next_batch().expect("batch") {
streamed += batch.num_rows();
}
assert_eq!(one_shot, 500);
assert_eq!(one_shot, streamed);
}
#[test]
fn the_default_options_match_passing_none() {
let sql = "SELECT sumState(number) AS s FROM numbers(3)";
let conn = Connection::open_in_memory().expect("open");
let none_result = conn
.query_arrow(sql)
.map(|r| r.schema().field(0).data_type().clone());
let conn2 = Connection::open_in_memory().expect("open2");
let default_result = conn2
.query_arrow_with_opts(sql, &ArrowOptions::default())
.map(|r| r.schema().field(0).data_type().clone());
match (&none_result, &default_result) {
(Err(_), Err(_)) => {}
(Ok(a), Ok(b)) => assert_eq!(
a, b,
"query_arrow and query_arrow_with_opts(default) diverged"
),
_ => panic!(
"query_arrow and query_arrow_with_opts(default) diverged: {:?} vs {:?}",
none_result.is_ok(),
default_result.is_ok()
),
}
assert!(none_result.is_err(), "got {:?}", none_result);
let conn3 = Connection::open_in_memory().expect("open3");
let opts = ArrowOptions {
unsupported_as_binary: true,
..ArrowOptions::default()
};
let binary = conn3.query_arrow_with_opts(sql, &opts).expect("binary");
assert_eq!(binary.schema().field(0).data_type(), &DataType::Binary);
}
#[test]
fn low_cardinality_becomes_a_dictionary_when_asked() {
let conn = Connection::open_in_memory().expect("open");
let sql = "SELECT CAST('x', 'LowCardinality(String)') AS c";
let default = conn.query_arrow(sql).expect("default");
assert!(
!matches!(
default.schema().field(0).data_type(),
DataType::Dictionary(..)
),
"the engine default materializes LowCardinality to its base type"
);
let opts = ArrowOptions {
low_cardinality_as_dictionary: true,
..ArrowOptions::default()
};
let dict = conn.query_arrow_with_opts(sql, &opts).expect("dictionary");
assert!(
matches!(dict.schema().field(0).data_type(), DataType::Dictionary(..)),
"got {:?}",
dict.schema().field(0).data_type()
);
}
#[test]
fn strings_can_be_emitted_as_binary() {
let conn = Connection::open_in_memory().expect("open");
let sql = "SELECT 'hello' AS s";
let opts = ArrowOptions {
string_as_string: false,
..ArrowOptions::default()
};
let reader = conn.query_arrow_with_opts(sql, &opts).expect("binary");
assert_eq!(reader.schema().field(0).data_type(), &DataType::Binary);
}
#[test]
fn options_reach_the_streaming_path_too() {
let mut conn = Connection::open_in_memory().expect("open");
let opts = ArrowOptions {
low_cardinality_as_dictionary: true,
..ArrowOptions::default()
};
let mut stream = conn
.query_stream_arrow_with_opts("SELECT CAST('x', 'LowCardinality(String)') AS c", &opts)
.expect("stream");
let batch = stream.next_batch().expect("batch").expect("one batch");
assert!(matches!(
batch.schema().field(0).data_type(),
DataType::Dictionary(..)
));
}
#[test]
fn params_and_options_combine_on_the_arrow_stream() {
let mut conn = Connection::open_in_memory().expect("open");
let opts = ArrowOptions {
low_cardinality_as_dictionary: true,
..ArrowOptions::default()
};
let mut stream = conn
.query_stream_arrow_with_params(
"SELECT CAST(toString(number), 'LowCardinality(String)') AS c \
FROM numbers({n:UInt64})",
[("n", "7")],
Some(&opts),
)
.expect("stream");
let mut rows = 0usize;
let mut saw_dictionary = false;
while let Some(batch) = stream.next_batch().expect("batch") {
if matches!(
batch.schema().field(0).data_type(),
DataType::Dictionary(..)
) {
saw_dictionary = true;
}
rows += batch.num_rows();
}
assert!(saw_dictionary, "expected a Dictionary-typed field");
assert_eq!(
rows, 7,
"the {{n:UInt64}} parameter must control the row count"
);
}
#[test]
fn a_one_shot_query_with_no_rows_yields_no_batches() {
let conn = Connection::open_in_memory().expect("open");
let reader = conn
.query_arrow("SELECT number FROM numbers(0)")
.expect("query_arrow");
assert_eq!(reader.schema().field(0).name(), "number");
assert_eq!(reader.schema().field(0).data_type(), &DataType::UInt64);
let rows: usize = reader.map(|b| b.expect("batch").num_rows()).sum();
assert_eq!(rows, 0);
}
#[test]
fn streamed_empty_result_preserves_schema() {
let mut conn = Connection::open_in_memory().expect("open");
let mut stream = conn
.query_stream_arrow("SELECT number FROM numbers(0)")
.expect("start");
assert!(stream.next_batch().expect("fetch").is_none());
let schema = stream.schema().expect("schema of empty result");
assert_eq!(schema.field(0).name(), "number");
assert_eq!(schema.field(0).data_type(), &DataType::UInt64);
}