rsql_driver_json 0.19.4

rsql json driver
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use rsql_driver::{Driver, Result, Value};
use std::path;
use std::path::PathBuf;

/// Returns the url to the specified dataset file.
pub fn dataset_url<S: AsRef<str>>(scheme: S, file_name: S) -> String {
    let scheme = scheme.as_ref();
    let file_name = file_name.as_ref();
    let crate_directory = env!("CARGO_MANIFEST_DIR");
    let mut path = PathBuf::from(crate_directory);
    path.push("..");

    if path.join("datasets").exists() {
        path.push("datasets");
    } else {
        path.push("..");
        path.push("datasets");
    }

    path.push(file_name);

    let dataset_path = path
        .to_string_lossy()
        .to_string()
        .replace(path::MAIN_SEPARATOR, "/");
    #[cfg(target_os = "windows")]
    let dataset_path = if dataset_path.is_empty() {
        dataset_path
    } else {
        format!("/{dataset_path}")
    };

    format!("{scheme}://{dataset_path}")
}

#[tokio::test(flavor = "multi_thread")]
async fn test_json_metadata() -> Result<()> {
    let database_url = dataset_url("json", "cheyenne.json");
    let driver = rsql_driver_json::Driver;
    let mut connection = driver.connect(&database_url).await?;

    let mut query_result = connection
        .query(
            r#"
            SELECT type
              FROM cheyenne
        "#,
            &[],
        )
        .await?;

    assert_eq!(query_result.columns(), vec!["type"]);
    let row = query_result.next().await.expect("expected a row");
    assert_eq!(row.len(), 1);
    let type_value = match &row[0] {
        Value::String(s) => s.trim_matches('"').to_string(),
        other => panic!("expected String, got {other:?}"),
    };
    assert_eq!(type_value, "Feature");
    assert!(query_result.next().await.is_none());

    let metadata = connection.metadata().await?;
    assert_eq!(metadata.catalogs().len(), 1);
    let catalog = metadata.current_catalog().expect("catalog");
    assert_eq!(catalog.schemas().len(), 1);
    let tables = catalog.current_schema().expect("schema").tables();
    assert_eq!(tables.len(), 1);
    let cheyenne_table = tables[0];
    assert_eq!(cheyenne_table.name(), "cheyenne");
    assert_eq!(cheyenne_table.columns().len(), 6);

    let type_column = cheyenne_table.get_column("type").expect("type column");
    assert_eq!(type_column.name(), "type");
    assert_eq!(type_column.data_type(), "str");
    assert!(!type_column.not_null());
    assert_eq!(type_column.default(), None);

    let geometry_column = cheyenne_table
        .get_column("geometry")
        .expect("geometry column");
    assert_eq!(geometry_column.name(), "geometry");
    assert_eq!(geometry_column.data_type(), "struct[2]");
    assert!(!geometry_column.not_null());
    assert_eq!(geometry_column.default(), None);

    let geo_type_column = cheyenne_table
        .get_column("geometry.type")
        .expect("geometry.type column");
    assert_eq!(geo_type_column.name(), "geometry.type");
    assert_eq!(geo_type_column.data_type(), "str");
    assert!(!geo_type_column.not_null());
    assert_eq!(geo_type_column.default(), None);

    let geo_coordinates_column = cheyenne_table
        .get_column("geometry.coordinates")
        .expect("geometry.coordinates column");
    assert_eq!(geo_coordinates_column.name(), "geometry.coordinates");
    assert_eq!(geo_coordinates_column.data_type(), "list[f64]");
    assert!(!geo_coordinates_column.not_null());
    assert_eq!(geo_coordinates_column.default(), None);

    let properties_column = cheyenne_table
        .get_column("properties")
        .expect("properties column");
    assert_eq!(properties_column.name(), "properties");
    assert_eq!(properties_column.data_type(), "struct[1]");
    assert!(!properties_column.not_null());
    assert_eq!(properties_column.default(), None);

    let properties_name_column = cheyenne_table
        .get_column("properties.name")
        .expect("properties.name column");
    assert_eq!(properties_name_column.name(), "properties.name");
    assert_eq!(properties_name_column.data_type(), "str");
    assert!(!properties_name_column.not_null());
    assert_eq!(properties_name_column.default(), None);

    connection.close().await?;
    Ok(())
}