#![allow(clippy::unwrap_used)]
use super::*;
fn key(expr: &str, direction: OrderDirection) -> KeysetKey {
KeysetKey {
expr: expr.to_string(),
direction,
cast: Cast::Text,
seekable: false,
}
}
fn predicate(keys: &[KeysetKey], values: &[Option<&str>], forward: bool) -> String {
let values: Vec<Option<String>> = values.iter().map(|v| v.map(str::to_string)).collect();
keyset_predicate(keys, &values, "pk", |p| p.to_string(), forward, 1).unwrap().0
}
#[test]
fn a_single_ascending_key_forward_places_nulls_last() {
let keys = [key("k", OrderDirection::Asc)];
assert_eq!(
predicate(&keys, &[Some("a")], true),
"((k > $1::text OR k IS NULL) OR (k = $1::text AND pk > $2))"
);
}
#[test]
fn from_a_null_a_descending_key_forward_reaches_every_value() {
let keys = [key("k", OrderDirection::Desc)];
assert_eq!(predicate(&keys, &[None], true), "(k IS NOT NULL OR (k IS NULL AND pk > $1))");
}
#[test]
fn from_a_null_an_ascending_key_forward_reaches_only_the_position() {
let keys = [key("k", OrderDirection::Asc)];
assert_eq!(predicate(&keys, &[None], true), "((k IS NULL AND pk > $1))");
}
#[test]
fn a_backward_page_reverses_every_comparison() {
let keys = [key("k", OrderDirection::Asc)];
assert_eq!(
predicate(&keys, &[Some("a")], false),
"(k < $1::text OR (k = $1::text AND pk < $2))"
);
}
#[test]
fn a_cursor_with_the_wrong_number_of_keys_is_refused() {
let keys = [key("k", OrderDirection::Asc)];
assert!(keyset_predicate(&keys, &[], "pk", |p| p.to_string(), true, 1).is_err());
}
#[test]
fn a_backward_order_reverses_every_key_and_the_position() {
let keys = [
key("a", OrderDirection::Asc),
key("b", OrderDirection::Desc),
];
assert_eq!(keyset_order(&keys, "pk", true), "a ASC, b DESC, pk ASC");
assert_eq!(keyset_order(&keys, "pk", false), "a DESC, b ASC, pk DESC");
}
#[test]
fn every_bound_value_is_resolved_as_text_before_its_cast() {
let cast = |cast| KeysetKey {
expr: "k".to_string(),
direction: OrderDirection::Asc,
cast,
seekable: false,
};
assert_eq!(cast(Cast::Scalar(ScalarFieldType::Boolean)).param("$1"), "($1::text)::boolean");
assert_eq!(cast(Cast::Scalar(ScalarFieldType::Uuid)).param("$1"), "$1::text");
assert_eq!(cast(Cast::Native("bool".to_string())).param("$1"), "($1::text)::boolean");
assert_eq!(cast(Cast::Native("varchar".to_string())).param("$1"), "$1::text");
assert_eq!(cast(Cast::Native("integer".to_string())).param("$1"), "($1::text)::integer");
assert_eq!(cast(Cast::Float).param("$1"), "($1::text)::float8");
}
#[test]
fn the_cursor_probe_asks_about_each_cast_value_with_its_bound_type() {
let key = |cast| KeysetKey {
expr: "k".to_string(),
direction: OrderDirection::Asc,
cast,
seekable: false,
};
let keys = [
key(Cast::Native("integer".to_string())),
key(Cast::Text),
key(Cast::Float),
key(Cast::Native("integer".to_string())),
];
let values = [
Some("7".to_string()),
Some("x".to_string()),
Some("abc".to_string()),
None,
];
let (sql, params) = cursor_values_probe(&keys, &values, Some("u")).unwrap();
assert_eq!(
sql,
"SELECT ARRAY[pg_input_is_valid($1::text, $2::text), pg_input_is_valid($3::text, \
$4::text), pg_input_is_valid($5::text, $6::text)] AS valid"
);
assert_eq!(params, ["7", "integer", "abc", "float8", "u", "uuid"]);
assert_eq!(cursor_values_probe(&keys[1..2], &values[1..2], None), None, "nothing is cast");
}
#[test]
fn the_signature_names_each_key_and_its_direction() {
let keys = [
key("a", OrderDirection::Asc),
key("b", OrderDirection::Desc),
];
assert_eq!(keyset_signature(&keys), "a ASC, b DESC");
assert_ne!(
keyset_signature(&[key("a", OrderDirection::Asc)]),
keyset_signature(&[key("a", OrderDirection::Desc)])
);
}